From 72c383fadab460e551ad6af121279aeb17b5b93a Mon Sep 17 00:00:00 2001 From: Gabor Kiss-Vamosi Date: Tue, 13 Sep 2022 13:21:53 +0200 Subject: [PATCH] docs(demo): update the README of the benchmark demo --- demos/benchmark/README.md | 111 ++++---------------------------------- 1 file changed, 11 insertions(+), 100 deletions(-) diff --git a/demos/benchmark/README.md b/demos/benchmark/README.md index c913ae00d..6d84e1722 100644 --- a/demos/benchmark/README.md +++ b/demos/benchmark/README.md @@ -1,5 +1,8 @@ # Benchmark demo + +![LVGL benchmark running](screenshot1.png) + ## Overview The benchmark demo tests the performance in various cases. @@ -12,109 +15,17 @@ On to top of the screen the title of the current test step, and the result of th ## Run the benchmark - In `lv_conf.h` or equivalent places set `LV_USE_DEMO_BENCHMARK 1` -- After `lv_init()` and initializing the drivers call `lv_demo_benchmark()` -- If you only want to run a specific scene for any purpose (e.g. debug, performance optimization etc.), you can call `lv_demo_benchmark_run_scene()` instead of `lv_demo_benchmark()`and pass the scene number. +- After `lv_init()` and initializing the drivers and call `lv_demo_benchmark(mode)` +- If you only want to run a specific scene for any purpose (e.g. debug, performance optimization etc.), you can call `lv_demo_benchmark_run_scene(mode, scene_idx)` instead of `lv_demo_benchmark()`and pass the scene number. - If you enabled trace output by setting macro `LV_USE_LOG` to `1` and trace level `LV_LOG_LEVEL` to `LV_LOG_LEVEL_USER` or higher, benchmark results are printed out in `csv` format. -- If you want to know when the testing is finished, you can register a callback function via `lv_demo_benchmark_register_finished_handler()` before calling `lv_demo_benchmark()` or `lv_demo_benchmark_run_scene()`. -- If you want to know the maximum rendering performance of the system, call `lv_demo_benchmark_set_max_speed(true)` before `lv_demo_benchmark()`. - -## Interpret the result - -The FPS is measured like this: -- load the next step -- in the display driver's `monitor_cb` accumulate the time-to-render and the number of cycles -- measure for 1 second -- calculate `FPS = time_sum / render_cnt` - -Note that it can result in very high FPS results for simple cases. -E.g. if some simple rectangles are drawn in 5 ms, the benchmark will tell it's 200 FPS. -So it ignores `LV_DISP_REFR_PERIOD` which tells LVGL how often it should refresh the screen. -In other words, the benchmark shows the FPS from the pure rendering time. - -By default, only the changed areas are refreshed. It means if only a few pixels are changed in 1 ms the benchmark will show 1000 FPS. To measure the performance with full screen refresh uncomment `lv_obj_invalidate(lv_scr_act())` in `monitor_cb()` in `lv_demo_benchmark.c`. - -![LVGL benchmark running](screenshot1.png) - -If you are doing performance analysis for 2D image processing optimization, LCD latency (flushing data to LCD) introduced by `disp_flush()` might dilute the performance results of the LVGL drawing process, hence make it harder to see your optimization results (gain or loss). To avoid such problem, please: - -1. Use a flag to control the LCD flushing inside `disp_flush()`. For example: - -```c -volatile bool disp_flush_enabled = true; - -/* Enable updating the screen (the flushing process) when disp_flush() is called by LVGL - */ -void disp_enable_update(void) -{ - disp_flush_enabled = true; -} - -/* Disable updating the screen (the flushing process) when disp_flush() is called by LVGL - */ -void disp_disable_update(void) -{ - disp_flush_enabled = false; -} - -static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p) -{ - if(disp_flush_enabled) { - GLCD_DrawBitmap(area->x1, //!< x - area->y1, //!< y - area->x2 - area->x1 + 1, //!< width - area->y2 - area->y1 + 1, //!< height - (const uint8_t *)color_p); - } - - /*IMPORTANT!!! - *Inform the graphics library that you are ready with the flushing*/ - lv_disp_flush_ready(disp_drv); -} -``` - -2. Disable flushing before calling `lv_demo_benchmark()` or `lv_demo_benchmark_run_scene()`, for example: - -```c -extern void disp_enable_update(void); -extern void disp_disable_update(void); - -static void on_benchmark_finished(void) -{ - disp_enable_update(); -} - -int main(void) -{ - lv_init(); - lv_port_disp_init(); - lv_port_indev_init(); - - LV_LOG("Running LVGL Benchmark..."); - LV_LOG("Please stand by..."); - LV_LOG("NOTE: You will NOT see anything until the end."); - - disp_disable_update(); - - lv_demo_benchmark_set_finished_cb(&on_benchmark_finished); - lv_demo_benchmark_set_max_speed(true); - lv_demo_benchmark(); - - //lv_demo_benchmark_run_scene(43); // run scene no 31 - - ... - while(1){ - lv_timer_handler(); //! run lv task at the max speed - } -} -``` +## Modes +The `mode` should be passed to `lv_demo_benchmark(mode)` or `lv_demo_benchmark_run_scene(mode, scene_idx)`. -3. Alternatively, you can use trace output to get the benchmark results in csv format by: - - Setting macro `LV_USE_LOG` to `1` - - Setting trace level `LV_LOG_LEVEL` to `LV_LOG_LEVEL_USER` or higher. - - +- `LV_DEMO_BENCHMARK_MODE_RENDER_AND_DRIVER` Render the scenes and show them on the display. Measure rendering time but it might contain extra time when LVGL waits for the driver. Run each scenes for a few seconds so the performance can be seen by eye too. As only the rendering time is measured and converted to FPS, really high values (e.g. 1000 FPS) are possible. +- `LV_DEMO_BENCHMARK_MODE_REAL` Similar to `RENDER_AND_DRIVER` but instead of measuring the rendering time only measure the real FPS of the system. E.g. even if a scene was rendered in 1 ms, but the screen is redrawn only in every 100 ms, the result will be 10 FPS. +- `LV_DEMO_BENCHMARK_MODE_RENDER_ONLY` Temporarily display the `flush_cb` so the pure rendering time will be measured. The display is not updated during the benchmark, only at the end when the summary table is shown. Renders a given number of frames from each scene and calculate the FPS from them. ## Result summary @@ -131,4 +42,4 @@ In the first section of the table, "Slow but common cases", those cases are disp Below this in the "All cases section" all the results are shown. The < 10 FPS results are shown with red, the >= 10 but < 20 FPS values are displayed with orange. -![LVGL benchmark result summary](https://github.com/lvgl/lvgl/tree/master/demos/benchmark/screenshot2.png?raw=true) +![LVGL benchmark result summary](screenshot2.png)