1# Copyright (c) 2021 Percepio AB 2# SPDX-License-Identifier: Apache-2.0 3 4config PERCEPIO_TRC_CFG_RECORDER_RTOS_FREERTOS 5 bool 6 default n 7 8config PERCEPIO_TRC_CFG_RECORDER_RTOS_THREADX 9 bool 10 default n 11 12config PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 13 bool 14 default n 15 16config PERCEPIO_TRC_CFG_RECORDER_RTOS_BAREMETAL 17 bool 18 default n 19 20choice PERCEPIO_TRC_CFG_START_MODE 21 prompt "Recorder Start Mode" 22 default PERCEPIO_TRC_START_MODE_START_FROM_HOST 23 help 24 TRC_START: Starts the tracing directly. In snapshot mode this allows for 25 starting the trace at any point in your code, assuming vTraceEnable(TRC_INIT) 26 has been called in the startup. 27 Can also be used for streaming without Tracealyzer control, e.g. to a local 28 flash file system (assuming such a "stream port", see trcStreamingPort.h). 29 30 TRC_START_AWAIT_HOST: For streaming mode only. Initializes the trace recorder 31 if necessary and waits for a Start command from Tracealyzer ("Start Recording" 32 button). This call is intentionally blocking! By calling vTraceEnable with 33 this option from the startup code, you start tracing at this point and capture 34 the early events. 35 36 TRC_START_FROM_HOST: Initializes the trace recorder, but does not start the tracing. 37 In snapshot mode, this must be followed by a vTraceEnable(TRC_START) sometime 38 later. 39 40config PERCEPIO_TRC_START_MODE_START 41 bool "Start" 42 43config PERCEPIO_TRC_START_MODE_START_AWAIT_HOST 44 bool "Start Await Host" 45 depends on PERCEPIO_TRC_RECORDER_MODE_STREAMING && !PERCEPIO_TRC_CFG_STREAM_PORT_RINGBUFFER 46 47config PERCEPIO_TRC_START_MODE_START_FROM_HOST 48 bool "Start From Host" 49 depends on PERCEPIO_TRC_RECORDER_MODE_STREAMING && !PERCEPIO_TRC_CFG_STREAM_PORT_RINGBUFFER 50endchoice 51 52choice PERCEPIO_TRC_CFG_STREAM_PORT 53 prompt "Stream Port" 54 depends on PERCEPIO_TRC_RECORDER_MODE_STREAMING 55 default PERCEPIO_TRC_CFG_STREAM_PORT_RTT 56 57config PERCEPIO_TRC_CFG_STREAM_PORT_RTT 58 bool "RTT" 59 depends on (ARM && PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR) || \ 60 PERCEPIO_TRC_CFG_RECORDER_RTOS_THREADX || \ 61 PERCEPIO_TRC_CFG_RECORDER_RTOS_FREERTOS 62 select USE_SEGGER_RTT if PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 63 64config PERCEPIO_TRC_CFG_STREAM_PORT_ITM 65 bool "ITM" 66 depends on (ARM && PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR) || \ 67 PERCEPIO_TRC_CFG_RECORDER_RTOS_THREADX || \ 68 PERCEPIO_TRC_CFG_RECORDER_RTOS_FREERTOS 69 70config PERCEPIO_TRC_CFG_STREAM_PORT_RINGBUFFER 71 bool "Ring Buffer" 72 73config PERCEPIO_TRC_CFG_STREAM_PORT_FILE 74 bool "File" 75 76config PERCEPIO_TRC_CFG_STREAM_PORT_TCPIP 77 bool "TCP/IP" 78 depends on !PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 79 80config PERCEPIO_TRC_CFG_STREAM_PORT_STM32_USB_CDC 81 bool "STM32 USB CDC" 82 depends on !PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 83 84config PERCEPIO_TRC_CFG_STREAM_PORT_ZEPHYR_SEMIHOST 85 bool "Semihost" 86 depends on PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR && \ 87 QEMU_TARGET && SEMIHOST 88 89endchoice 90 91if PERCEPIO_TRC_CFG_STREAM_PORT_RTT 92rsource "../streamports/Jlink_RTT/Kconfig" 93endif 94if PERCEPIO_TRC_CFG_STREAM_PORT_ITM 95rsource "../streamports/ARM_ITM/Kconfig" 96endif 97if PERCEPIO_TRC_CFG_STREAM_PORT_RINGBUFFER 98rsource "../streamports/RingBuffer/Kconfig" 99endif 100if PERCEPIO_TRC_CFG_STREAM_PORT_FILE 101rsource "../streamports/File/Kconfig" 102endif 103if PERCEPIO_TRC_CFG_STREAM_PORT_ZEPHYR_SEMIHOST 104rsource "../kernelports/Zephyr/streamports/Semihost/Kconfig" 105endif 106 107choice PERCEPIO_TRC_CFG_RECORDER_BUFFER_ALLOCATION 108 prompt "Recorder Allocation Mode" 109 default PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_STATIC 110 help 111 Specifies how the recorder buffer is allocated (also in case of streaming, in 112 port using the recorders internal temporary buffer) 113 114 Values: 115 PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_STATIC - Static allocation (internal) 116 PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC - Malloc in vTraceEnable 117 PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_CUSTOM - Use vTraceSetRecorderDataBuffer 118 119 Static and dynamic mode does the allocation for you, either in compile time 120 (static) or in runtime (malloc). 121 The custom mode allows you to control how and where the allocation is made, 122 for details see PERCEPIO_TRC_ALLOC_CUSTOM_BUFFER and vTraceSetRecorderDataBuffer(). 123 124config PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_STATIC 125 bool "Static allocation" 126 127config PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC 128 bool "Dynamic allocation" 129 130config PERCEPIO_TRC_RECORDER_BUFFER_ALLOCATION_CUSTOM 131 bool "Custom allocation" 132endchoice 133 134 135menu "Coverage" 136 depends on !PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 137config PERCEPIO_TRC_CFG_SCHEDULING_ONLY 138 bool "Only Record Scheduling Events" 139 default n 140 141config PERCEPIO_TRC_CFG_INCLUDE_MEMMANG_EVENTS 142 bool "Trace Memory Management Events" 143 depends on !PERCEPIO_TRC_CFG_SCHEDULING_ONLY 144 default y 145 help 146 This controls if malloc and free calls should be traced. Disable this to exclude 147 malloc/free calls, or enable it to include such events in the trace. 148 149config PERCEPIO_TRC_CFG_INCLUDE_USER_EVENTS 150 bool "Trace User Events" 151 depends on !PERCEPIO_TRC_CFG_SCHEDULING_ONLY 152 default y 153 help 154 If this is disabled, all code related to User Events is excluded in order 155 to reduce code size. Any attempts to store User Events are then silently 156 ignored. 157 158 User Events are application-generated events, like "printf" but for the 159 trace log, generated using vTracePrint and vTracePrintF. 160 The formatting is done on host-side, by Tracealyzer. User Events are 161 therefore much faster than a console printf and can often be used 162 in timing critical code without problems. 163 164 Note: In streaming mode, User Events are used to provide error messages 165 and warnings from the recorder (in case of incorrect configuration) for 166 display in Tracealyzer. Disabling user events will also disable these 167 warnings. You can however still catch them by calling xTraceGetLastError 168 or by putting breakpoints in prvTraceError and prvTraceWarning. 169 170config PERCEPIO_TRC_CFG_INCLUDE_ISR_TRACING 171 bool "Trace ISR Events" 172 depends on !PERCEPIO_TRC_CFG_SCHEDULING_ONLY 173 default y 174 help 175 If this is disabled, the code for recording Interrupt Service Routines is 176 excluded, in order to reduce code size. This means that any calls to 177 vTraceStoreISRBegin/vTraceStoreISREnd will be ignored. 178 This does not completely disable ISR tracing, in cases where an ISR is 179 calling a traced kernel service. These events will still be recorded and 180 show up in anonymous ISR instances in Tracealyzer, with names such as 181 "ISR sending to <queue name>". 182 To disable such tracing, please refer to vTraceSetFilterGroup and vTraceSetFilterMask. 183 184config PERCEPIO_TRC_CFG_INCLUDE_READY_EVENTS 185 bool "Trace Task Ready Events" 186 depends on !PERCEPIO_TRC_CFG_SCHEDULING_ONLY 187 default y 188 help 189 If enabled, events are recorded when tasks enter scheduling state "ready". 190 This allows Tracealyzer to show the initial pending time before tasks enter 191 the execution state, and present accurate response times. 192 If disabled, "ready events" are not created, which allows for recording 193 longer traces in the same amount of RAM. 194 195config PERCEPIO_TRC_CFG_INCLUDE_OSTICK_EVENTS 196 bool "Trace OS Tick Events" 197 depends on !PERCEPIO_TRC_CFG_SCHEDULING_ONLY 198 default y 199 help 200 If this is enabled, events will be generated whenever the OS clock is 201 increased. If disabled, OS tick events are not generated, which allows for 202 recording longer traces in the same amount of RAM. 203endmenu 204 205 206menu "Control Task" 207config PERCEPIO_TRC_CFG_CTRL_TASK_PRIORITY 208 int "Control Task Priority" 209 range 0 32 if PERCEPIO_TRC_CFG_RECORDER_RTOS_FREERTOS || PERCEPIO_TRC_CFG_RECORDER_RTOS_THREADX 210 range -32 32 if PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 211 default 4 212 help 213 In streaming mode, TzCtrl is used to receive start/stop commands from 214 Tracealyzer and in some cases also to transmit the trace data (for stream 215 ports that uses the internal buffer, like TCP/IP). For such stream ports, 216 make sure the TzCtrl priority is high enough to ensure reliable periodic 217 execution and transfer of the data, but low enough to avoid disturbing any 218 time-sensitive functions. 219 220 In Snapshot mode, TzCtrl is only used for the stack usage monitoring and is 221 not created if stack monitoring is disabled. PERCEPIO_TRC_CFG_CTRL_TASK_PRIORITY should 222 be low, to avoid disturbing any time-sensitive tasks. 223 224config PERCEPIO_TRC_CFG_CTRL_TASK_DELAY 225 int "Control Task Delay" 226 range 1 1000000000 227 default 10 228 help 229 The delay between loops of the TzCtrl task (see PERCEPIO_TRC_CFG_CTRL_TASK_PRIORITY), 230 which affects the frequency of the stack monitoring. 231 232 In streaming mode, this also affects the trace data transfer if you are using 233 a stream port leveraging the internal buffer (like TCP/IP). A shorter delay 234 increases the CPU load of TzCtrl somewhat, but may improve the performance of 235 of the trace streaming, especially if the trace buffer is small. 236 237config PERCEPIO_TRC_CFG_CTRL_TASK_STACK_SIZE 238 int "Control Task Stack Size" 239 range 1 1048576 240 default 256 241 help 242 The stack size of the Tracealyzer Control (TzCtrl) task. 243 See PERCEPIO_TRC_CFG_CTRL_TASK_PRIORITY for further information about TzCtrl. 244endmenu 245 246menuconfig PERCEPIO_TRC_CFG_ENABLE_STACK_MONITOR 247 bool "Stack Monitor" 248 select TRACING_STACK if PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 249 select THREAD_STACK_INFO if PERCEPIO_TRC_CFG_RECORDER_RTOS_ZEPHYR 250 default y 251 help 252 If enabled (1), the recorder periodically reports the unused stack space of 253 all active tasks. The stack monitoring runs in the Tracealyzer Control task, 254 TzCtrl. This task is always created by the recorder when in streaming mode. 255 In snapshot mode, the TzCtrl task is only used for stack monitoring and is 256 not created unless this is enabled. 257 258if PERCEPIO_TRC_CFG_ENABLE_STACK_MONITOR 259 260config PERCEPIO_TRC_CFG_STACK_MONITOR_MAX_TASKS 261 int "Stack Monitor Max Tasks" 262 range 1 64 263 default 15 264 help 265 This controls how many tasks that can be monitored by the stack monitor. 266 If this is too small, some tasks will be excluded and a warning is shown. 267 268config PERCEPIO_TRC_CFG_STACK_MONITOR_MAX_REPORTS 269 int "Stack Monitor Max Reports" 270 range 1 64 271 default 1 272 help 273 This defines how many tasks that will be subject to stack usage analysis for 274 each execution of the Tracealyzer Control task (TzCtrl). Note that the stack 275 monitoring cycles between the tasks, so this does not affect WHICH tasks that 276 are monitored, but HOW OFTEN each task stack is analyzed. 277 278 This setting can be combined with PERCEPIO_TRC_CFG_CTRL_TASK_DELAY to tune the 279 frequency of the stack monitoring. This is motivated since the stack analysis 280 can take some time to execute. 281 However, note that the stack analysis runs in a separate task (TzCtrl) that 282 can be executed on low priority. This way, you can avoid that the stack 283 analysis disturbs any time-sensitive tasks. 284 285endif # PERCEPIO_TRC_CFG_ENABLE_STACK_MONITOR 286 287 288menu "ISR" 289config PERCEPIO_TRC_CFG_MAX_ISR_NESTING 290 int "Max ISR Nesting" 291 range 1 1048576 292 default 8 293 help 294 Defines how many levels of interrupt nesting the recorder can handle, in 295 case multiple ISRs are traced and ISR nesting is possible. If this 296 is exceeded, the particular ISR will not be traced and the recorder then 297 logs an error message. This setting is used to allocate an internal stack 298 for keeping track of the previous execution context (4 byte per entry). 299 300config PERCEPIO_TRC_CFG_ISR_TAILCHAINING_THRESHOLD 301 int "ISR Tailchaining Threshold" 302 range 0 4194304 303 default 0 304 help 305 If tracing multiple ISRs, this setting allows for accurate display of the 306 context-switching also in cases when the ISRs execute in direct sequence. 307 308 vTraceStoreISREnd normally assumes that the ISR returns to the previous 309 context, i.e., a task or a preempted ISR. But if another traced ISR 310 executes in direct sequence, Tracealyzer may incorrectly display a minimal 311 fragment of the previous context in between the ISRs. 312 313 By using PERCEPIO_TRC_CFG_ISR_TAILCHAINING_THRESHOLD you can avoid this. This is 314 however a threshold value that must be measured for your specific setup. 315 See http://percepio.com/2014/03/21/isr_tailchaining_threshold/ 316 317 The default setting is 0, meaning "disabled" and that you may get an 318 extra fragments of the previous context in between tail-chained ISRs. 319endmenu 320 321 322menu "Debug" 323config PERCEPIO_TRC_CFG_RECORDER_DATA_INIT 324 int "Data Init" 325 default 1 326 help 327 Macro that states wether the recorder data should have an initial value. 328 329 In very specific cases where traced objects are created before main(), 330 the recorder will need to be started even before that. In these cases, 331 the recorder data would be initialized by xTraceInitialize() but could 332 then later be overwritten by the initialization value. 333 If this is an issue for you, set PERCEPIO_TRC_CFG_RECORDER_DATA_INIT to 0. 334 The following code can then be used before any traced objects are created: 335 336 extern uint32_t RecorderEnabled; 337 RecorderEnabled = 0; 338 xTraceInitialize(); 339 340 After the clocks are properly initialized, use vTraceEnable(...) to start 341 the tracing. 342 343config PERCEPIO_TRC_CFG_USE_TRACE_ASSERT 344 bool "Trace Asserts" 345 default n 346 help 347 Enable or disable debug asserts. Information regarding any assert that is 348 triggered will be in trcAssert.c. 349endmenu 350 351 352if PERCEPIO_TRC_RECORDER_MODE_SNAPSHOT 353 354menu "Snapshot Config" 355choice PERCEPIO_TRC_CFG_SNAPSHOT_MODE 356 prompt "Snapshot Mode" 357 default PERCEPIO_TRC_SNAPSHOT_MODE_RING_BUFFER 358 help 359 With PERCEPIO_TRC_CFG_SNAPSHOT_MODE set to PERCEPIO_TRC_CFG_SNAPSHOT_MODE_RING_BUFFER, the 360 events are stored in a ring buffer, i.e., where the oldest events are 361 overwritten when the buffer becomes full. This allows you to get the last 362 events leading up to an interesting state, e.g., an error, without having 363 to store the whole run since startup. 364 365 When PERCEPIO_TRC_CFG_SNAPSHOT is PERCEPIO_TRC_SNAPSHOT_MODE_STOP_WHEN_FULL, the 366 recording is stopped when the buffer becomes full. This is useful for 367 recording events following a specific state, e.g., the startup sequence. 368 369config PERCEPIO_TRC_SNAPSHOT_MODE_RING_BUFFER 370 bool "Ring buffer mode" 371 372config PERCEPIO_TRC_SNAPSHOT_MODE_RING_STOP_WHEN_FULL 373 bool "Stop when full" 374endchoice 375 376config PERCEPIO_TRC_CFG_EVENT_BUFFER_SIZE 377 int "Event Buffer Size" 378 range 1 4194304 379 default 1000 380 help 381 This defines the capacity of the event buffer, i.e., the number of records 382 it may store. Most events use one record (4 byte), although some events 383 require multiple 4-byte records. You should adjust this to the amount of RAM 384 available in the target system. 385 386 Default value is 1000, which means that 4000 bytes is allocated for the 387 event buffer. 388 389config PERCEPIO_TRC_CFG_INCLUDE_FLOAT_SUPPORT 390 bool "Include Float Support" 391 default 0 392 help 393 If this is zero (0), the support for logging floating point values in 394 vTracePrintF is stripped out, in case floating point values are not used or 395 supported by the platform used. 396 397 Floating point values are only used in vTracePrintF and its subroutines, to 398 allow for storing float (%f) or double (%lf) arguments. 399 400 vTracePrintF can be used with integer and string arguments in either case. 401 402config PERCEPIO_TRC_CFG_SYMBOL_TABLE_SIZE 403 int "Symbol Table Size" 404 range 1 4194304 405 default 800 406 help 407 This defines the capacity of the symbol table, in bytes. This symbol table 408 stores User Event labels and names of deleted tasks, queues, or other kernel 409 objects. If you don't use User Events or delete any kernel 410 objects you set this to a very low value. The minimum recommended value is 4. 411 A size of zero (0) is not allowed since a zero-sized array may result in a 412 32-bit pointer, i.e., using 4 bytes rather than 0. 413 414menu "Advanced Settings" 415config PERCEPIO_TRC_CFG_HEAP_SIZE_BELOW_16M 416 bool "Heap Size Below 16M" 417 default n 418 help 419 An integer constant that can be used to reduce the buffer usage of memory 420 allocation events (malloc/free). This value should be 1 if the heap size is 421 below 16 MB (2^24 byte), and you can live with reported addresses showing the 422 lower 24 bits only. If set to 0, you get the full 32-bit addresses. 423 424config PERCEPIO_TRC_CFG_USE_IMPLICIT_IFE_RULES 425 bool "Use Implicit IFE Rules" 426 default y 427 help 428 Tracealyzer groups the events into "instances" based on Instance Finish 429 Events (IFEs), produced either by default rules or calls to the recorder 430 functions vTraceInstanceFinishedNow and vTraceInstanceFinishedNext. 431 432 If PERCEPIO_TRC_CFG_USE_IMPLICIT_IFE_RULES is one (1), the default IFE rules are 433 used, resulting in a "typical" grouping of events into instances. 434 If these rules don't give appropriate instances in your case, you can 435 override the default rules using vTraceInstanceFinishedNow/Next for one 436 or several tasks. The default IFE rules are then disabled for those tasks. 437 438 If PERCEPIO_TRC_CFG_USE_IMPLICIT_IFE_RULES is zero (0), the implicit IFE rules are 439 disabled globally. You must then call vTraceInstanceFinishedNow or 440 vTraceInstanceFinishedNext to manually group the events into instances, 441 otherwise the tasks will appear a single long instance. 442 443 The default IFE rules count the following events as "instance finished": 444 - Task delay, delay until 445 - Task suspend 446 - Blocking on "input" operations, i.e., when the task is waiting for the 447 next a message/signal/event. But only if this event is blocking. 448 449config PERCEPIO_TRC_CFG_USE_16BIT_OBJECT_HANDLES 450 bool "Use 16 Bit Object Handles" 451 default n 452 help 453 If set to 0 (zero), the recorder uses 8-bit handles to identify kernel 454 objects such as tasks and queues. This limits the supported number of 455 concurrently active objects to 255 of each type (tasks, queues, mutexes, 456 etc.) Note: 255, not 256, since handle 0 is reserved. 457 458 If set to 1 (one), the recorder uses 16-bit handles to identify kernel 459 objects such as tasks and queues. This limits the supported number of 460 concurrent objects to 65535 of each type (object class). However, since the 461 object property table is limited to 64 KB, the practical limit is about 462 3000 objects in total. 463 464 Default is 0 (8-bit handles) 465 466 NOTE: An object with handle above 255 will use an extra 4-byte record in 467 the event buffer whenever the object is referenced. Moreover, some internal 468 tables in the recorder gets slightly larger when using 16-bit handles. 469 470config PERCEPIO_TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER 471 bool "Use Separate User Event Buffer" 472 default n 473 help 474 Set PERCEPIO_TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER to 1 to enable the 475 separate user event buffer (UB). 476 In this mode, user events are stored separately from other events, 477 e.g., RTOS events. Thereby you can get a much longer history of 478 user events as they don't need to share the buffer space with more 479 frequent events. 480 481 The UB is typically used with the snapshot ring-buffer mode, so the 482 recording can continue when the main buffer gets full. And since the 483 main buffer then overwrites the earliest events, Tracealyzer displays 484 "Unknown Actor" instead of task scheduling for periods with UB data only. 485 486 In UB mode, user events are structured as UB channels, which contains 487 a channel name and a default format string. Register a UB channel using 488 xTraceRegisterUBChannel. 489 490 Events and data arguments are written using vTraceUBEvent and 491 vTraceUBData. They are designed to provide efficient logging of 492 repeating events, using the same format string within each channel. 493 494 Examples: 495 traceString chn1 = xTraceRegisterString("Channel 1"); 496 traceString fmt1 = xTraceRegisterString("Event!"); 497 traceUBChannel UBCh1 = xTraceRegisterUBChannel(chn1, fmt1); 498 499 traceString chn2 = xTraceRegisterString("Channel 2"); 500 traceString fmt2 = xTraceRegisterString("X: %d, Y: %d"); 501 traceUBChannel UBCh2 = xTraceRegisterUBChannel(chn2, fmt2); 502 503 // Result in "[Channel 1] Event!" 504 vTraceUBEvent(UBCh1); 505 506 // Result in "[Channel 2] X: 23, Y: 19" 507 vTraceUBData(UBCh2, 23, 19); 508 509 You can also use the other user event functions, like vTracePrintF. 510 as they are then rerouted to the UB instead of the main event buffer. 511 vTracePrintF then looks up the correct UB channel based on the 512 provided channel name and format string, or creates a new UB channel 513 if no match is found. The format string should therefore not contain 514 "random" messages but mainly format specifiers. Random strings should 515 be stored using %s and with the string as an argument. 516 517 // Creates a new UB channel ("Channel 2", "%Z: %d") 518 vTracePrintF(chn2, "%Z: %d", value1); 519 520 // Finds the existing UB channel 521 vTracePrintF(chn2, "%Z: %d", value2); 522 523config PERCEPIO_TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE 524 int "Separate User Event Buffer Size" 525 depends on PERCEPIO_TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER 526 range 1 4194304 527 default 200 528 help 529 This defines the capacity of the user event buffer (UB), in number of slots. 530 A single user event can use multiple slots, depending on its arguments. 531 532config PERCEPIO_TRC_CFG_UB_CHANNELS 533 int "User Event Buffer Channels" 534 depends on PERCEPIO_TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER 535 range 0 4194304 536 default 32 537 help 538 This defines the number of User Event Buffer Channels (UB channels). 539 These are used to structure the events when using the separate user 540 event buffer, and contains both a User Event Channel (the name) and 541 a default format string for the channel. 542endmenu # "Advanced Settings" 543endmenu # "Snapshot Config" 544 545endif # PERCEPIO_TRC_RECORDER_MODE_SNAPSHOT 546 547 548if PERCEPIO_TRC_RECORDER_MODE_STREAMING 549 550menu "Streaming Config" 551config PERCEPIO_TRC_CFG_ENTRY_SLOTS 552 int "Entry Slots" 553 range 1 4194304 554 default 50 555 help 556 The maximum number of objects and symbols that can be stored. This includes: 557 - Task names 558 - Named ISRs (vTraceSetISRProperties) 559 - Named kernel objects (vTraceStoreKernelObjectName) 560 - User event channels (xTraceStringRegister) 561 562 If this value is too small, not all symbol names will be stored and the 563 trace display will be affected. In that case, there will be warnings 564 (logged as User Events) from the TzCtrl task, which monitors this. 565 566config PERCEPIO_TRC_CFG_ENTRY_SYMBOL_MAX_LENGTH 567 int "Symbol Max Length" 568 range 1 28 569 default 28 570 help 571 The maximum length of symbol names, including: 572 - Task names 573 - Named ISRs (vTraceSetISRProperties) 574 - Named kernel objects (vTraceStoreKernelObjectName) 575 - User event channel names (xTraceStringRegister) 576 577 If longer symbol names are used, they will be truncated by the recorder, 578 which will affect the trace display. In that case, there will be warnings 579 (logged as User Events) from the TzCtrl task, which monitors this. 580endmenu # "Streaming Config" 581 582endif # PERCEPIO_TRC_RECORDER_MODE_STREAMING 583
