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