Introduction
À l'ère de l'Internet of Everything, les performances du produit sont cruciales et le temps de démarrage du système est un élément important des performances du système, car les utilisateurs doivent attendre que le démarrage du système soit terminé avant d'utiliser l'appareil. Pour les appareils tels que les voitures qui doivent souvent être démarrées à froid, des temps de démarrage courts sont essentiels (personne n'aime attendre des dizaines de secondes avant d'entrer dans les destinations de navigation), dans les appareils de transactions financières, les serveurs de commerce électronique, les appareils de communication en temps réel, etc. Il existe également des scénarios d'application élevés, alors comment pouvons-nous compléter le démarrage de deuxième niveau avec les capacités existantes du système standard OpenAtom OpenHarmony (OpenHarmony en abrégé) ? Dans cet article, les étudiants en recherche et développement de Shenzhen Youbo Terminal Technology Co., Ltd. présentent un ensemble de solutions pour optimiser le temps de démarrage du système standard OpenHarmony. Grâce à l'optimisation correspondante du matériel, du noyau et du cadre, le démarrage du système le temps peut être raccourci autant que possible.
Montrer les résultats
Voici une vidéo de comparaison du temps de démarrage du système avant et après l'optimisation. Le temps de démarrage avant l'optimisation est d'environ 18 secondes et le temps de démarrage après l'optimisation est d'environ 7 secondes.
environnement de développement
Plate-forme matérielle : RK3588
Version du système : version OpenHarmony 3.1
Langage de développement : C, C++
Quatre étapes pour découvrir l'optimisation du temps de démarrage du système standard OpenHarmony
1. Ajuster l'utilisation des ressources matérielles
Ajustez les paramètres de configuration correspondants des ressources matérielles pour obtenir autant que possible l'état de fonctionnement optimal. Les ressources matérielles auxquelles il est fait référence ici se réfèrent à la RAM et à la FLASH.
RAM : le réglage du stockage doit être ajusté dans le fichier d'arborescence des périphériques <fichier .dtsi> conformément aux documents d'orientation du fabricant, tels que le réglage de la fréquence d'horloge mémoire-fréquence de stockage, le réglage de la bande passante mémoire bande passante mémoire et la mémoire de synchronisation de la mémoire - Timings, etc., la couche Kernel peut ajuster les valeurs correspondantes telles que swappiness, dirty_ratio, dirty_background_ratio, min_free_kbytes, etc., pour obtenir un réglage des performances du stockage.
FLASH : par exemple, ajustez l'élément physical_block_size. Le système de fichiers actuel utilisé par OpenHarmony est ext4. Vous pouvez régler le cache, le mode, la compression et le nettoyage après vous être familiarisé avec le système de fichiers ext4. Réduisez la sortie des journaux KMSG et HiLog et ajustez leur niveau de sortie.
2. Optimisation du temps de démarrage du noyau
Pendant la phase de démarrage du noyau, la détection du matériel, le chargement du pilote, le montage du système de fichiers, la configuration du réseau, etc. seront effectués, et la partie qui prend du temps est essentiellement le chargement du pilote, car il y aura des tentatives répétées et des temps de veille au milieu, ce qui Pendant le processus de démarrage, certains sous-systèmes inutiles peuvent être coupés, comme le bootchart.
3. Optimisation du temps de démarrage du framework système
Lorsque la couche système est démarrée, de nombreux services doivent être démarrés. Vous pouvez démarrer les services nécessaires du système en parallèle et retarder le démarrage des services non essentiels. Ces services sont chargés du chargement à la fin du démarrage. Parmi eux, celui qui prend du temps est chargé par so, qui peut être traité de manière multi-thread.Pour charger, le code de démonstration pour le chargement multi-thread de plusieurs fichiers so est affiché ci-dessous;
#include <iostream>
#include <dlfcn.h>
#include <thread>
#include <vector>
#include <string>
void thread_func(void* handle){
// 空函数
}
int main(){
std::vector<std::string> lib_names = {"mpp1.so", "mpp2.so", "mpp3.so"};
std::vector<void*> handles;
for (const auto& lib_name : lib_names) {
void* handle = dlopen(lib_name.c_str(), RTLD_LAZY);
if (handle == nullptr) {
std::cerr << "Error loading library " << lib_name << ": " << dlerror() << std::endl;
return 1;
}
handles.push_back(handle);
}
std::vector<std::thread> threads;
for (const auto& handle : handles) {
threads.emplace_back(thread_func, handle);
}
for (auto& thread : threads) {
thread.join();
}
for (const auto& handle : handles) {
dlclose(handle);
}
return 0;
}
Si vous trouvez que le fichier so chargé est trop volumineux, vous pouvez utiliser le multithreading pour charger le fichier so en segments.
4. Optimisation de l'affichage de l'animation de démarrage
L'idée d'optimisation est grossièrement d'entrer dans la fonction principale de bootAnimation, de précharger les images d'animation sous la forme d'un tableau ou d'une liste chaînée, et d'activer un taux de rafraîchissement de 60 images par seconde. Pourquoi avez-vous besoin d'ouvrir 60 images ici ? Parce que s'il est réglé sur 30 images, après une perte d'image, il y aura un bégaiement visible à l'œil nu. Une fois l'image lue, elle sera retardée d'environ quelques centaines de millisecondes avant d'entrer sur le bureau, car il faut un certain temps au lanceur pour charger l'application installée. Ce qui suit fait partie de l'optimisation de l'animation de démarrage :
1. Augmentez la priorité de l'animation de démarrage et du processus de rendu ;
"services" : [{
"name" : "render_service",
"path" : ["/system/bin/render_service"],
"uid" : "root",
"importance" : -20,
"gid" : ["system", "shell", "uhid", "root"]
}, {
"name" : "bootanimation",
"path" : ["/system/bin/bootanimation"],
"once" : 1,
"importance" : -20,
"uid" : "root",
"gid" : ["system", "shell", "uhid", "root"]
}
]
2. Chargez l'image d'animation de démarrage à l'avance ;
ReadZipFile(BOOT_PIC_ZIP, imageVector_, jsonConfig);
imgVecSize_ = static_cast<int32_t>(imageVector_.size());
if (imgVecSize_ <= 0) {
PostTask(std::bind(&AppExecFwk::EventRunner::Stop, runner_));
LOGE("zip pic num is 0.");
return;
}
SortZipFile(imageVector_);
3. Spécifiez la fréquence d'images d'affichage de l'animation de démarrage ;
OHOS::Rosen::VSyncReceiver::FrameCallback fcb = {
.userData_ = this,
.callback_ = std::bind(&BootAnimation::onVsync, this),
};
int32_t changefreq = static_cast<int32_t>((1000.0 / freq_) / 16);
ret = receiver_->SetVSyncRate(fcb, changefreq);
L'optimisation du démarrage nécessite certains outils à analyser, tels que des outils de port série et des graphiques visuels générés par bootchart pour analyse.
Le système standard OpenHarmony intègre le bootchart par défaut. Ce qui suit décrit comment utiliser l'outil bootchart pour obtenir des données de performances de démarrage et générer des images de performances :
(1) Une fois le démarrage terminé, exécutez le shell hdc_std
(2) Exécutez begetctl bootchart enable
(3) Exécutez le redémarrage ou éteignez et redémarrez
(4) Exécutez begetctl bootchart stop
(5) Exécutez begetctl bootchart disable
(6) Allez dans le dossier /data/bootchart/ pour vérifier s'il y a
(7) en-tête、proc_diskstats.log、proc_ps.log、proc_stat.log
(8) Exécutez la commande dans le répertoire /data/bootchart/ : tar -czf bootchart.tgz *
(9) Exporter bootchart.tgz sur le disque local
(10) fichier hdc_std recv /data/bootchart/bootchart.tgz ./
(11) Générer une image de performances de démarrage java -jar bootchart.jar bootchart.tgz
Le bootchart.jar ci-dessus doit télécharger le code source pour compiler et générer ou télécharger le package jar qui a été compilé par d'autres. Adresse de téléchargement du code source https://sourceforge.net/projects/bootchart/.
La figure ci-dessous montre la visualisation des performances OpenHarmony générée par bootchart.
Résumer
Grâce à l'introduction de cet article, vous devriez avoir une compréhension préliminaire des fonctions d'optimisation des performances sous le système standard OpenHarmony. Si vous êtes intéressé par le contenu de cet article, vous pouvez le rechercher et l'utiliser conformément à l'introduction de cet article. Dans le même temps, davantage de développeurs sont invités à partager avec nous les résultats du développement, l'interprétation technique et l'expérience.