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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [kernel/] [current/] [include/] [instrmnt.h] - Blame information for rev 786

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 786 skrzyp
#ifndef CYGONCE_KERNEL_INSTRMNT_HXX
2
#define CYGONCE_KERNEL_INSTRMNT_HXX
3
 
4
//==========================================================================
5
//
6
//      instrmnt.hxx
7
//
8
//      Kernel Instrumentation mechanism
9
//
10
//==========================================================================
11
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
12
// -------------------------------------------                              
13
// This file is part of eCos, the Embedded Configurable Operating System.   
14
// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2010 Free Software Foundation, Inc.
15
//
16
// eCos is free software; you can redistribute it and/or modify it under    
17
// the terms of the GNU General Public License as published by the Free     
18
// Software Foundation; either version 2 or (at your option) any later      
19
// version.                                                                 
20
//
21
// eCos is distributed in the hope that it will be useful, but WITHOUT      
22
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    
23
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    
24
// for more details.                                                        
25
//
26
// You should have received a copy of the GNU General Public License        
27
// along with eCos; if not, write to the Free Software Foundation, Inc.,    
28
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
29
//
30
// As a special exception, if other files instantiate templates or use      
31
// macros or inline functions from this file, or you compile this file      
32
// and link it with other works to produce a work based on this file,       
33
// this file does not by itself cause the resulting work to be covered by   
34
// the GNU General Public License. However the source code for this file    
35
// must still be made available in accordance with section (3) of the GNU   
36
// General Public License v2.                                               
37
//
38
// This exception does not invalidate any other reasons why a work based    
39
// on this file might be covered by the GNU General Public License.         
40
// -------------------------------------------                              
41
// ####ECOSGPLCOPYRIGHTEND####                                              
42
//==========================================================================
43
//#####DESCRIPTIONBEGIN####
44
//
45
// Author(s):    nickg
46
// Contributors: nickg, andrew.lunn@ascom.ch
47
// Date:         2000-05-04
48
// Purpose:      Define kernel instrumentation
49
// Description:  A set of definitions and macros used to implement an
50
//               instrumentation interface for the kernel.
51
//               NOTE: Don't use CYG_UNUSED_PARAM (or similar) here to
52
//               silence warnings about unused variables when using the
53
//               empty macro definitions. Otherwise this can cause problems
54
//               with volatile arguments and cause other side-effects.
55
//               Instead it is up to the caller to ensure that unused
56
//               arguments don't cause warnings
57
// Usage:        #include <cyg/kernel/instrmnt.hxx>
58
//
59
//####DESCRIPTIONEND####
60
//
61
//==========================================================================
62
 
63
#include <cyg/kernel/ktypes.h>
64
#include <cyg/infra/cyg_ass.h>            // assertion macros
65
 
66
// -------------------------------------------------------------------------
67
// Underlying instrumentation function
68
 
69
externC void cyg_instrument( cyg_uint32 type, CYG_ADDRWORD arg1, CYG_ADDRWORD arg2 );
70
 
71
// -------------------------------------------------------------------------
72
// The following functions are used to enable and disable specific
73
// instrumentation classes and events. The class must be one of the
74
// class defines below. The event may be one of the event defines below
75
// or zero, in which case all of the events in the class are enabled or
76
// disabled.
77
 
78
#ifdef CYGDBG_KERNEL_INSTRUMENT_FLAGS
79
 
80
externC void cyg_instrument_enable( cyg_uint32 cl, cyg_uint32 event );
81
 
82
externC void cyg_instrument_disable( cyg_uint32 cl, cyg_uint32 event );
83
 
84
externC cyg_bool cyg_instrument_state( cyg_uint32 cl, cyg_uint32 event );
85
 
86
#endif
87
 
88
#ifdef CYGDBG_KERNEL_INSTRUMENT_MSGS
89
externC char * cyg_instrument_msg(CYG_WORD16 type);
90
#endif 
91
 
92
// -------------------------------------------------------------------------
93
// Instrumentation macros
94
 
95
#ifdef CYGPKG_KERNEL_INSTRUMENT
96
 
97
#define CYG_INSTRUMENT(_type_,_arg1_,_arg2_) cyg_instrument(_type_, (CYG_ADDRWORD)(_arg1_), (CYG_ADDRWORD)(_arg2_))
98
 
99
#else   // ifdef CYGPKG_KERNEL_INSTRUMENT
100
 
101
#define CYG_INSTRUMENT(_type_,_arg1_,_arg2_)
102
 
103
#endif  // ifdef CYGPKG_KERNEL_INSTRUMENT
104
 
105
// -------------------------------------------------------------------------
106
// Type codes.
107
// Each code is 16 bit with an event class in the top 8 bits
108
// and an event code in the lower 8 bits.
109
 
110
// Event classes
111
#define CYG_INSTRUMENT_CLASS_SCHED              0x0100
112
#define CYG_INSTRUMENT_CLASS_THREAD             0x0200
113
#define CYG_INSTRUMENT_CLASS_INTR               0x0300
114
#define CYG_INSTRUMENT_CLASS_MUTEX              0x0400
115
#define CYG_INSTRUMENT_CLASS_CONDVAR            0x0500
116
#define CYG_INSTRUMENT_CLASS_BINSEM             0x0600
117
#define CYG_INSTRUMENT_CLASS_CNTSEM             0x0700
118
#define CYG_INSTRUMENT_CLASS_CLOCK              0x0800
119
#define CYG_INSTRUMENT_CLASS_ALARM              0x0900
120
#define CYG_INSTRUMENT_CLASS_MBOXT              0x0a00
121
#define CYG_INSTRUMENT_CLASS_SMP                0x0b00
122
#define CYG_INSTRUMENT_CLASS_MLQ                0x0c00
123
#define CYG_INSTRUMENT_CLASS_FLAG               0x0d00
124
#define CYG_INSTRUMENT_CLASS_BITMAP             0x0e00
125
 
126
#define CYG_INSTRUMENT_CLASS_USER               0x0f00
127
 
128
#define CYG_INSTRUMENT_CLASS_MAX                CYG_INSTRUMENT_CLASS_USER
129
 
130
// Scheduler events
131
#define CYG_INSTRUMENT_EVENT_SCHED_LOCK         1
132
#define CYG_INSTRUMENT_EVENT_SCHED_UNLOCK       2
133
#define CYG_INSTRUMENT_EVENT_SCHED_RESCHEDULE   3
134
#define CYG_INSTRUMENT_EVENT_SCHED_TIMESLICE    4
135
 
136
// Thread events
137
#define CYG_INSTRUMENT_EVENT_THREAD_SWITCH      1
138
#define CYG_INSTRUMENT_EVENT_THREAD_SLEEP       2
139
#define CYG_INSTRUMENT_EVENT_THREAD_WAKE        3
140
#define CYG_INSTRUMENT_EVENT_THREAD_SUSPEND     4
141
#define CYG_INSTRUMENT_EVENT_THREAD_RESUME      5
142
#define CYG_INSTRUMENT_EVENT_THREAD_PRIORITY    6
143
#define CYG_INSTRUMENT_EVENT_THREAD_DELAY       7
144
#define CYG_INSTRUMENT_EVENT_THREAD_ALARM       8
145
#define CYG_INSTRUMENT_EVENT_THREAD_ENTER       9
146
#define CYG_INSTRUMENT_EVENT_THREAD_CHECK_STACK 10
147
#define CYG_INSTRUMENT_EVENT_THREAD_ATTACH_STACK 11
148
#define CYG_INSTRUMENT_EVENT_THREAD_CREATE      12
149
 
150
// Interrupt events
151
#define CYG_INSTRUMENT_EVENT_INTR_RAISE         1
152
#define CYG_INSTRUMENT_EVENT_INTR_END           2
153
#define CYG_INSTRUMENT_EVENT_INTR_RESTORE       3
154
#define CYG_INSTRUMENT_EVENT_INTR_POST_DSR      4
155
#define CYG_INSTRUMENT_EVENT_INTR_CALL_DSR      5
156
#define CYG_INSTRUMENT_EVENT_INTR_ATTACH        6
157
#define CYG_INSTRUMENT_EVENT_INTR_DETACH        7
158
#define CYG_INSTRUMENT_EVENT_INTR_SET_VSR       8
159
#define CYG_INSTRUMENT_EVENT_INTR_DISABLE       9
160
#define CYG_INSTRUMENT_EVENT_INTR_ENABLE        10
161
#define CYG_INSTRUMENT_EVENT_INTR_MASK          11
162
#define CYG_INSTRUMENT_EVENT_INTR_UNMASK        12
163
#define CYG_INSTRUMENT_EVENT_INTR_CONFIGURE     13
164
#define CYG_INSTRUMENT_EVENT_INTR_ACK           14
165
#define CYG_INSTRUMENT_EVENT_INTR_CHAIN_ISR     15
166
#define CYG_INSTRUMENT_EVENT_INTR_SET_CPU       16
167
#define CYG_INSTRUMENT_EVENT_INTR_GET_CPU       17
168
 
169
// Mutex events
170
#define CYG_INSTRUMENT_EVENT_MUTEX_LOCK         1
171
#define CYG_INSTRUMENT_EVENT_MUTEX_WAIT         2
172
#define CYG_INSTRUMENT_EVENT_MUTEX_LOCKED       3
173
#define CYG_INSTRUMENT_EVENT_MUTEX_TRY          4
174
#define CYG_INSTRUMENT_EVENT_MUTEX_UNLOCK       5
175
#define CYG_INSTRUMENT_EVENT_MUTEX_WAKE         6
176
#define CYG_INSTRUMENT_EVENT_MUTEX_RELEASE      7
177
#define CYG_INSTRUMENT_EVENT_MUTEX_RELEASED     8
178
 
179
// Condition variable events
180
#define CYG_INSTRUMENT_EVENT_CONDVAR_WAIT       1
181
#define CYG_INSTRUMENT_EVENT_CONDVAR_WOKE       2
182
#define CYG_INSTRUMENT_EVENT_CONDVAR_SIGNAL     3
183
#define CYG_INSTRUMENT_EVENT_CONDVAR_WAKE       4
184
#define CYG_INSTRUMENT_EVENT_CONDVAR_BROADCAST  5
185
#define CYG_INSTRUMENT_EVENT_CONDVAR_TIMED_WAIT 6
186
 
187
// Binary semaphore events
188
#define CYG_INSTRUMENT_EVENT_BINSEM_CLAIM       1
189
#define CYG_INSTRUMENT_EVENT_BINSEM_WAIT        2
190
#define CYG_INSTRUMENT_EVENT_BINSEM_WOKE        3
191
#define CYG_INSTRUMENT_EVENT_BINSEM_TRY         4
192
#define CYG_INSTRUMENT_EVENT_BINSEM_POST        5
193
#define CYG_INSTRUMENT_EVENT_BINSEM_WAKE        6
194
#define CYG_INSTRUMENT_EVENT_BINSEM_TIMEOUT     7
195
 
196
// Counting semaphore events
197
#define CYG_INSTRUMENT_EVENT_CNTSEM_CLAIM       1
198
#define CYG_INSTRUMENT_EVENT_CNTSEM_WAIT        2
199
#define CYG_INSTRUMENT_EVENT_CNTSEM_WOKE        3
200
#define CYG_INSTRUMENT_EVENT_CNTSEM_TRY         4
201
#define CYG_INSTRUMENT_EVENT_CNTSEM_POST        5
202
#define CYG_INSTRUMENT_EVENT_CNTSEM_WAKE        6
203
#define CYG_INSTRUMENT_EVENT_CNTSEM_TIMEOUT     7
204
 
205
// Clock events
206
#define CYG_INSTRUMENT_EVENT_CLOCK_TICK_START   1
207
#define CYG_INSTRUMENT_EVENT_CLOCK_TICK_END     2
208
#define CYG_INSTRUMENT_EVENT_CLOCK_ISR          3
209
 
210
// Alarm events
211
#define CYG_INSTRUMENT_EVENT_ALARM_ADD          1
212
#define CYG_INSTRUMENT_EVENT_ALARM_REM          2
213
#define CYG_INSTRUMENT_EVENT_ALARM_CALL         3
214
#define CYG_INSTRUMENT_EVENT_ALARM_INIT         4
215
#define CYG_INSTRUMENT_EVENT_ALARM_TRIGGER      5
216
#define CYG_INSTRUMENT_EVENT_ALARM_INTERVAL     6
217
 
218
// Mboxt events
219
#define CYG_INSTRUMENT_EVENT_MBOXT_WAIT         1
220
#define CYG_INSTRUMENT_EVENT_MBOXT_GET          2
221
#define CYG_INSTRUMENT_EVENT_MBOXT_GOT          3
222
#define CYG_INSTRUMENT_EVENT_MBOXT_TIMEOUT      4
223
#define CYG_INSTRUMENT_EVENT_MBOXT_WAKE         5
224
#define CYG_INSTRUMENT_EVENT_MBOXT_TRY          6
225
#define CYG_INSTRUMENT_EVENT_MBOXT_PUT          7
226
 
227
// SMP events
228
#define CYG_INSTRUMENT_EVENT_SMP_LOCK_INC       1
229
#define CYG_INSTRUMENT_EVENT_SMP_LOCK_ZERO      2
230
#define CYG_INSTRUMENT_EVENT_SMP_LOCK_SET       3
231
#define CYG_INSTRUMENT_EVENT_SMP_CPU_START      4
232
#define CYG_INSTRUMENT_EVENT_SMP_LOCK_WAIT      5
233
#define CYG_INSTRUMENT_EVENT_SMP_LOCK_GOT       6
234
#define CYG_INSTRUMENT_EVENT_SMP_RESCHED_SEND   8
235
#define CYG_INSTRUMENT_EVENT_SMP_RESCHED_RECV   9
236
 
237
// MLQ scheduler events
238
 
239
#define CYG_INSTRUMENT_EVENT_MLQ_SCHEDULE       1
240
#define CYG_INSTRUMENT_EVENT_MLQ_RESCHEDULE     2
241
#define CYG_INSTRUMENT_EVENT_MLQ_ADD            3
242
#define CYG_INSTRUMENT_EVENT_MLQ_REM            4
243
#define CYG_INSTRUMENT_EVENT_MLQ_TIMESLICE      5
244
#define CYG_INSTRUMENT_EVENT_MLQ_YIELD          6
245
#define CYG_INSTRUMENT_EVENT_MLQ_ENQUEUE        7
246
#define CYG_INSTRUMENT_EVENT_MLQ_DEQUEUE        8
247
#define CYG_INSTRUMENT_EVENT_MLQ_REMOVE         9
248
 
249
// Flag events
250
 
251
#define CYG_INSTRUMENT_EVENT_FLAG_WAIT          1
252
#define CYG_INSTRUMENT_EVENT_FLAG_WOKE          2
253
#define CYG_INSTRUMENT_EVENT_FLAG_SETBITS       3
254
#define CYG_INSTRUMENT_EVENT_FLAG_MASKBITS      4
255
#define CYG_INSTRUMENT_EVENT_FLAG_TIMEOUT       5
256
#define CYG_INSTRUMENT_EVENT_FLAG_WAKE          6
257
#define CYG_INSTRUMENT_EVENT_FLAG_POLL          7
258
 
259
// Bitmap scheduler events
260
 
261
#define CYG_INSTRUMENT_EVENT_BITMAP_SCHEDULE    1
262
#define CYG_INSTRUMENT_EVENT_BITMAP_ADD         2
263
#define CYG_INSTRUMENT_EVENT_BITMAP_REM         3
264
#define CYG_INSTRUMENT_EVENT_BITMAP_ENQUEUE     4
265
#define CYG_INSTRUMENT_EVENT_BITMAP_DEQUEUE     5
266
#define CYG_INSTRUMENT_EVENT_BITMAP_REMOVE      6
267
 
268
// User events
269
 
270
#define CYG_INSTRUMENT_EVENT_USER_1             1
271
#define CYG_INSTRUMENT_EVENT_USER_2             2
272
#define CYG_INSTRUMENT_EVENT_USER_3             3
273
#define CYG_INSTRUMENT_EVENT_USER_4             4
274
#define CYG_INSTRUMENT_EVENT_USER_5             5
275
#define CYG_INSTRUMENT_EVENT_USER_6             6
276
#define CYG_INSTRUMENT_EVENT_USER_7             7
277
#define CYG_INSTRUMENT_EVENT_USER_8             8
278
#define CYG_INSTRUMENT_EVENT_USER_9             9
279
#define CYG_INSTRUMENT_EVENT_USER_10            10
280
#define CYG_INSTRUMENT_EVENT_USER_11            11
281
#define CYG_INSTRUMENT_EVENT_USER_12            12
282
#define CYG_INSTRUMENT_EVENT_USER_13            13
283
#define CYG_INSTRUMENT_EVENT_USER_14            14
284
#define CYG_INSTRUMENT_EVENT_USER_15            15
285
#define CYG_INSTRUMENT_EVENT_USER_16            16
286
#define CYG_INSTRUMENT_EVENT_USER_17            17
287
#define CYG_INSTRUMENT_EVENT_USER_18            18
288
#define CYG_INSTRUMENT_EVENT_USER_19            19
289
 
290
// -------------------------------------------------------------------------
291
// Handy-dandy macro to make event codes.
292
// Note that this relies on the definitions above
293
// having a well defined form.
294
 
295
#define CYGINST_EVENT(_class_,_event_) \
296
((CYG_INSTRUMENT_CLASS_##_class_)|(CYG_INSTRUMENT_EVENT_##_class_##_##_event_))
297
 
298
// -------------------------------------------------------------------------
299
// Scheduler instrumentation macros
300
 
301
#ifdef CYGDBG_KERNEL_INSTRUMENT_SCHED
302
 
303
#define CYG_INSTRUMENT_SCHED(_event_,_arg1_,_arg2_) \
304
    CYG_INSTRUMENT(CYGINST_EVENT(SCHED,_event_),_arg1_,_arg2_)
305
 
306
#else
307
 
308
#define CYG_INSTRUMENT_SCHED(_event_,_arg1_,_arg2_)
309
 
310
#endif
311
 
312
// -------------------------------------------------------------------------
313
// Thread instrumentation macros
314
 
315
#ifdef CYGDBG_KERNEL_INSTRUMENT_THREAD
316
 
317
#define CYG_INSTRUMENT_THREAD(_event_,_arg1_,_arg2_) \
318
    CYG_INSTRUMENT(CYGINST_EVENT(THREAD,_event_),_arg1_,_arg2_)
319
 
320
#else
321
 
322
#define CYG_INSTRUMENT_THREAD(_event_,_arg1_,_arg2_)
323
 
324
#endif
325
 
326
// -------------------------------------------------------------------------
327
// Interrupt instrumentation macros
328
 
329
#ifdef CYGDBG_KERNEL_INSTRUMENT_INTR
330
 
331
#define CYG_INSTRUMENT_INTR(_event_,_arg1_,_arg2_) \
332
    CYG_INSTRUMENT(CYGINST_EVENT(INTR,_event_),_arg1_,_arg2_)
333
 
334
#else
335
 
336
#define CYG_INSTRUMENT_INTR(_event_,_arg1_,_arg2_)
337
 
338
#endif
339
 
340
// -------------------------------------------------------------------------
341
// Mutex instrumentation macros
342
 
343
#ifdef CYGDBG_KERNEL_INSTRUMENT_MUTEX
344
 
345
#define CYG_INSTRUMENT_MUTEX(_event_,_arg1_,_arg2_) \
346
    CYG_INSTRUMENT(CYGINST_EVENT(MUTEX,_event_),_arg1_,_arg2_)
347
 
348
#else
349
 
350
#define CYG_INSTRUMENT_MUTEX(_event_,_arg1_,_arg2_)
351
 
352
#endif
353
 
354
// -------------------------------------------------------------------------
355
// Condition variable instrumentation macros
356
 
357
#ifdef CYGDBG_KERNEL_INSTRUMENT_CONDVAR
358
 
359
#define CYG_INSTRUMENT_CONDVAR(_event_,_arg1_,_arg2_) \
360
    CYG_INSTRUMENT(CYGINST_EVENT(CONDVAR,_event_),_arg1_,_arg2_)
361
 
362
#else
363
 
364
#define CYG_INSTRUMENT_CONDVAR(_event_,_arg1_,_arg2_)
365
 
366
#endif
367
 
368
// -------------------------------------------------------------------------
369
// Binary semaphore instrumentation macros
370
 
371
#ifdef CYGDBG_KERNEL_INSTRUMENT_BINSEM
372
 
373
#define CYG_INSTRUMENT_BINSEM(_event_,_arg1_,_arg2_) \
374
    CYG_INSTRUMENT(CYGINST_EVENT(BINSEM,_event_),_arg1_,_arg2_)
375
 
376
#else
377
 
378
#define CYG_INSTRUMENT_BINSEM(_event_,_arg1_,_arg2_)
379
 
380
#endif
381
 
382
// -------------------------------------------------------------------------
383
// Counting semaphore instrumentation macros
384
 
385
#ifdef CYGDBG_KERNEL_INSTRUMENT_CNTSEM
386
 
387
#define CYG_INSTRUMENT_CNTSEM(_event_,_arg1_,_arg2_) \
388
    CYG_INSTRUMENT(CYGINST_EVENT(CNTSEM,_event_),_arg1_,_arg2_)
389
 
390
#else
391
 
392
#define CYG_INSTRUMENT_CNTSEM(_event_,_arg1_,_arg2_)
393
 
394
#endif
395
 
396
// -------------------------------------------------------------------------
397
// Clock instrumentation macros
398
 
399
#ifdef CYGDBG_KERNEL_INSTRUMENT_CLOCK
400
 
401
#define CYG_INSTRUMENT_CLOCK(_event_,_arg1_,_arg2_) \
402
    CYG_INSTRUMENT(CYGINST_EVENT(CLOCK,_event_),_arg1_,_arg2_)
403
 
404
#else
405
 
406
#define CYG_INSTRUMENT_CLOCK(_event_,_arg1_,_arg2_)
407
 
408
#endif
409
 
410
// -------------------------------------------------------------------------
411
// Alarm instrumentation macros
412
 
413
#ifdef CYGDBG_KERNEL_INSTRUMENT_ALARM
414
 
415
#define CYG_INSTRUMENT_ALARM(_event_,_arg1_,_arg2_) \
416
    CYG_INSTRUMENT(CYGINST_EVENT(ALARM,_event_),_arg1_,_arg2_)
417
 
418
#else
419
 
420
#define CYG_INSTRUMENT_ALARM(_event_,_arg1_,_arg2_)
421
 
422
#endif
423
 
424
// -------------------------------------------------------------------------
425
// Mboxt instrumentation macros
426
 
427
#ifdef CYGDBG_KERNEL_INSTRUMENT_MBOXT
428
 
429
#define CYG_INSTRUMENT_MBOXT(_event_,_arg1_,_arg2_) \
430
    CYG_INSTRUMENT(CYGINST_EVENT(MBOXT,_event_),_arg1_,_arg2_)
431
 
432
#else
433
 
434
#define CYG_INSTRUMENT_MBOXT(_event_,_arg1_,_arg2_)
435
 
436
#endif
437
 
438
// -------------------------------------------------------------------------
439
// SMP instrumentation
440
 
441
#ifdef CYGDBG_KERNEL_INSTRUMENT_SMP
442
 
443
#define CYG_INSTRUMENT_SMP(_event_,_arg1_,_arg2_) \
444
    CYG_INSTRUMENT(CYGINST_EVENT(SMP,_event_),_arg1_,_arg2_)
445
 
446
#else
447
 
448
#define CYG_INSTRUMENT_SMP(_event_,_arg1_,_arg2_)
449
 
450
#endif
451
 
452
 
453
// -------------------------------------------------------------------------
454
// MLQ instrumentation
455
 
456
#ifdef CYGDBG_KERNEL_INSTRUMENT_MLQ
457
 
458
#define CYG_INSTRUMENT_MLQ(_event_,_arg1_,_arg2_) \
459
    CYG_INSTRUMENT(CYGINST_EVENT(MLQ,_event_),_arg1_,_arg2_)
460
 
461
#else
462
 
463
#define CYG_INSTRUMENT_MLQ(_event_,_arg1_,_arg2_)
464
 
465
#endif
466
 
467
// -------------------------------------------------------------------------
468
// Flag instrumentation
469
 
470
#ifdef CYGDBG_KERNEL_INSTRUMENT_FLAG
471
 
472
#define CYG_INSTRUMENT_FLAG(_event_,_arg1_,_arg2_) \
473
    CYG_INSTRUMENT(CYGINST_EVENT(FLAG,_event_),_arg1_,_arg2_)
474
 
475
#else
476
 
477
#define CYG_INSTRUMENT_FLAG(_event_,_arg1_,_arg2_)
478
 
479
#endif
480
 
481
// -------------------------------------------------------------------------
482
// Bitmap instrumentation
483
 
484
#ifdef CYGDBG_KERNEL_INSTRUMENT_BITMAP
485
 
486
#define CYG_INSTRUMENT_BITMAP(_event_,_arg1_,_arg2_) \
487
    CYG_INSTRUMENT(CYGINST_EVENT(BITMAP,_event_),_arg1_,_arg2_)
488
 
489
#else
490
 
491
#define CYG_INSTRUMENT_BITMAP(_event_,_arg1_,_arg2_)
492
 
493
#endif
494
 
495
// -------------------------------------------------------------------------
496
// User instrumentation
497
 
498
#ifdef CYGDBG_KERNEL_INSTRUMENT_USER
499
 
500
#define CYG_INSTRUMENT_USER(_event_,_arg1_,_arg2_) \
501
    CYG_INSTRUMENT((CYG_INSTRUMENT_CLASS_USER|(_event_)),_arg1_,_arg2_)
502
 
503
#else
504
 
505
#define CYG_INSTRUMENT_USER(_event_,_arg1_,_arg2_)
506
 
507
#endif
508
 
509
 
510
// -------------------------------------------------------------------------
511
#endif // ifndef CYGONCE_KERNEL_INSTRMNT_HXX
512
// EOF instrmnt.h

powered by: WebSVN 2.1.0

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