meta data for this page
  •  

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
embedded:nordic:sdk5:log [2024/10/14 21:59] – niziakembedded:nordic:sdk5:log [2024/10/24 11:26] (current) – niziak
Line 16: Line 16:
       * filters: check if module log level and log entry severity level matches       * filters: check if module log level and log entry severity level matches
       * if log entry should be send to backend - call ''nrf_log_backend_put''       * if log entry should be send to backend - call ''nrf_log_backend_put''
-      * **BACKEND:** process log entry and do really printf-like processing and sending / TX-ing / storing+      * **BACKEND:** process log entry and do really printf-like processing and sending / TX-ing / storing for background processing (**NRF_CLI_LOG_BACKEND**)
   * ''nrf_log_frontend_dequeue()'' return ''false'' if ringbuffer is empty   * ''nrf_log_frontend_dequeue()'' return ''false'' if ringbuffer is empty
  
Line 64: Line 64:
  
   * Circular buffer of **NRF_LOG_BUFSIZE (1024)**:   * Circular buffer of **NRF_LOG_BUFSIZE (1024)**:
-    * Its aim is to store log entry from app as fast as poosible without further processing.+    * Its aim is to store log entry from app as fast as possible without further processing.
     * DEFERRED: should be big enough to store all log entries until apps calls log to be processed.     * DEFERRED: should be big enough to store all log entries until apps calls log to be processed.
   * Dynamic memory pool:   * Dynamic memory pool:
Line 73: Line 73:
     * It looks like to be designed for background backends. Counting semaphore will keep object locked until all backends finish.     * It looks like to be designed for background backends. Counting semaphore will keep object locked until all backends finish.
     * Background backends:     * Background backends:
-      * ???+      * **NRF_CLI_LOG_BACKEND**
   * Backends are using temporary string buffers - this is the real place where printf-like function writes generated strings.   * Backends are using temporary string buffers - this is the real place where printf-like function writes generated strings.
     * ''NRF_LOG_BACKEND_UART_TEMP_BUFFER_SIZE 64''     * ''NRF_LOG_BACKEND_UART_TEMP_BUFFER_SIZE 64''
Line 90: Line 90:
  
   * ''put''   * ''put''
-    * printf-like processing +    * UART/RTT:  
-    * memobj with log entry is released (''put()'' - counting semaphore decremented)+      * printf-like processing 
 +      * memobj with log entry is released (''put()'' - counting semaphore decremented)
     * CLI:      * CLI: 
-      * memobj is not released. ''get()'' is called to lock it. And entry is pushed to own queue. +      * memobj is not released. ''get()'' is called to lock it. And entry is pushed to own **queue**. 
-      * ''nrf_cli_process()'' --> ''cli_log_entry_process()'' gets one entry from queue. After processing it free memobj by ''put()''+      * own **queue** size is defined by ''NRF_CLI_DEF'' 
 +      * ''nrf_cli_process()'' --> ''cli_log_entry_process()'' gets entries from **queue**. It makes memobj free by ''put()'' after processing.
   * ''panic_set'':   * ''panic_set'':
     * RTT: empty     * RTT: empty
Line 100: Line 102:
   * ''flush'' - empty function in most backends   * ''flush'' - empty function in most backends
     * CLI: ''(void)cli_log_entry_process(p_cli, true);''     * CLI: ''(void)cli_log_entry_process(p_cli, true);''
 +
 +  * ''nrf_cli_process()''
 +    * ''cli_log_entry_process()''
 +      * ''do { } while'' loop until no log entries in CLI internal **queue**. So all entries are processed at once.
 +      * result of processing is passed to printf-like writer ''p_cli->p_fprintf_ctx'' == ''nrf_cli_print_stream''
 +        * ''cli_write'' which maps to ''nrf_cli_uart_transport_api.write'' == ''cli_uart_write''
 +        * cli_uart_write puts data to UART TX ringbuffer defined by macro NRF_CLI_UART_DEF
 +
 +===== using CLI and deferred log =====
 +
 +SUMMARY:
 +  * app logs data and metadata to ringbuffer: ''NRF_LOG_BUFSIZE'' - so must be big enough to handle all entries until log process
 +  * app idle calls: ''NRF_LOG_PROCESS()''
 +    * if dynamic log levels enabled it filter what to log
 +    * it copies entries from ringbuffer to memobj (dynamic memory of size ''NRF_LOG_MSGPOOL_ELEMENT_SIZE (20) x NRF_LOG_MSGPOOL_ELEMENT_COUNT (8)'')
 +    * each one memobj log entry is passed to all active backends (multiple reference locking possible by counting semaphore)
 +      * UART backend: it process log entry (printf-like formatting) and put it in UART TX buffer. Memobj log entry is released.
 +      * RTT backend: it process log entry (printf-like formatting) and put it in RTT buffer. Memobj log entry is released.
 +      * CLI backend: it puts log entry into own queue. Memobj log entry is  **NOT released**. 
 +        * **conclusion**: dynamic memory pool size ''NRF_LOG_MSGPOOL_ELEMENT_SIZE (20) x NRF_LOG_MSGPOOL_ELEMENT_COUNT (8)'' should be the same as ''NRF_LOG_BUFSIZE''.
 +        * **conclusion**: CLI LOG queue sized defined by macro ''NRF_CLI_DEF'' should be big enough to track all memobj log entries.
 +  * app idle calls: ''nrf_cli_process()''
 +    * whole queue is processed in loop
 +      * each memobj log entry is processed (printf-like formatting) and put into UART TX ring buffer (size defined by ''NRF_CLI_UART_DEF'').
 +