Datasets:
Ekhlass
/
Flutter_Documentation

Dataset card Data Studio Files
xet
 Community
1
text
stringlengths
1
474
and needless processing.When you encounter calls to saveLayer,
ask yourself these questions:<topic_end>
<topic_start>Checking for non-cached images
Caching an image with RepaintBoundary is good,
when it makes sense.One of the most expensive operations,
from a resource perspective,
is rendering a texture using an image file.
First, the compressed image
is fetched from persistent storage.
The image is decompressed into host memory (GPU memory),
and transferred to device memory (RAM).In other words, image I/O can be expensive.
The cache provides snapshots of complex hierarchies so
they are easier to render in subsequent frames.
Because raster cache entries are expensive to
construct and take up loads of GPU memory,
cache images only where absolutely necessary.You can see which images are being cached by enabling the
PerformanceOverlayLayer.checkerboardRasterCacheImages switch.Run the app and look for images rendered with a randomly colored
checkerboard, indicating that the image is cached.
As you interact with the scene, the checkerboarded images
should remain constant—you don’t want to see flickering,
which would indicate that the cached image is being re-cached.In most cases, you want to see checkerboards on static images,
but not on non-static images. If a static image isn’t cached,
you can cache it by placing it into a RepaintBoundary
widget. Though the engine might still ignore a repaint
boundary if it thinks the image isn’t complex enough.<topic_end>
<topic_start>
Viewing the widget rebuild profiler
The Flutter framework is designed to make it hard to create
applications that are not 60fps and smooth. Often, if you have jank,
it’s because there is a simple bug causing more of the UI to be
rebuilt each frame than required. The Widget rebuild profiler
helps you debug and fix performance problems due to these sorts
of bugs.You can view the widget rebuilt counts for the current screen and
frame in the Flutter plugin for Android Studio and IntelliJ.
For details on how to do this, see Show performance data<topic_end>
<topic_start>
Benchmarking
You can measure and track your app’s performance by writing
benchmark tests. The Flutter Driver library provides support
for benchmarking. Using this integration test framework,
you can generate metrics to track the following:Tracking these benchmarks allows you to be informed when a
regression is introduced that adversely affects performance.For more information, check out Integration testing.<topic_end>
<topic_start>
Other resources
The following resources provide more information on using
Flutter’s tools and debugging in Flutter:
<topic_end>
<topic_start>Debugging performance for web apps
info Note
Profiling Flutter web apps requires Flutter version 3.14 or later.The Flutter framework emits timeline events as it works to build frames,
draw scenes, and track other activity such as garbage collections.
These events are exposed in the
Chrome DevTools performance panel for debugging.You can also emit your own timeline events using the dart:developer
Timeline and TimelineTask APIs for further performance analysis.<topic_end>
<topic_start>
Optional flags to enhance tracing
To configure which timeline events are tracked, set any of the following top-level properties to true
in your app’s main method.<topic_end>
<topic_start>
Instructions
<topic_end>
<topic_start>Shader compilation jank
info Note
To learn how to use the Performance View
(part of Flutter DevTools)
for debugging performance issues,
see Using the Performance view.If the animations on your mobile app appear to be janky,
but only on the first run,
this is likely due to shader compilation.
Flutter’s long term solution to
shader compilation jank is Impeller,
which is in the stable release for iOS
and in preview behind a flag on Android.While we work on making Impeller fully production ready,
you can mitigate shader compilation jank by bundling
precompiled shaders with an iOS app.
Unfortunately, this approach doesn’t work well on Android
due to precompiled shaders being device or GPU-specific.
The Android hardware ecosystem is large enough that the
GPU-specific precompiled shaders bundled with an application
will work on only a small subset of devices,
and will likely make jank worse on the other devices,
or even create rendering errors.Also, note that we aren’t planning to make
improvements to the developer experience for creating
precompiled shaders described below. Instead,
we are focusing our energies on the more robust
solution to this problem that Impeller offers.<topic_end>
<topic_start>
What is shader compilation jank?
A shader is a piece of code that runs on a
GPU (graphics processing unit).
When the Skia graphics backend that Flutter uses for rendering
sees a new sequence of draw commands for the first time,
it sometimes generates and compiles a
custom GPU shader for that sequence of commands.
This allows that sequence and potentially similar sequences
to render as fast as possible.Unfortunately, Skia’s shader generation and compilation
happens in sequence with the frame workload.
The compilation could cost up to a few hundred milliseconds
whereas a smooth frame needs to be drawn within 16 milliseconds
for a 60 fps (frame-per-second) display.