Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "benchmark/benchmark.h"
     18 
     19 #include "android-base/stringprintf.h"
     20 #include "androidfw/ApkAssets.h"
     21 #include "androidfw/AssetManager.h"
     22 #include "androidfw/AssetManager2.h"
     23 #include "androidfw/ResourceTypes.h"
     24 
     25 #include "BenchmarkHelpers.h"
     26 #include "data/basic/R.h"
     27 #include "data/libclient/R.h"
     28 #include "data/styles/R.h"
     29 
     30 namespace app = com::android::app;
     31 namespace basic = com::android::basic;
     32 namespace libclient = com::android::libclient;
     33 
     34 namespace android {
     35 
     36 constexpr const static char* kFrameworkPath = "/system/framework/framework-res.apk";
     37 
     38 static void BM_AssetManagerLoadAssets(benchmark::State& state) {
     39   std::string path = GetTestDataPath() + "/basic/basic.apk";
     40   while (state.KeepRunning()) {
     41     std::unique_ptr<const ApkAssets> apk = ApkAssets::Load(path);
     42     AssetManager2 assets;
     43     assets.SetApkAssets({apk.get()});
     44   }
     45 }
     46 BENCHMARK(BM_AssetManagerLoadAssets);
     47 
     48 static void BM_AssetManagerLoadAssetsOld(benchmark::State& state) {
     49   String8 path((GetTestDataPath() + "/basic/basic.apk").data());
     50   while (state.KeepRunning()) {
     51     AssetManager assets;
     52     assets.addAssetPath(path, nullptr /* cookie */, false /* appAsLib */,
     53                         false /* isSystemAsset */);
     54 
     55     // Force creation.
     56     assets.getResources(true);
     57   }
     58 }
     59 BENCHMARK(BM_AssetManagerLoadAssetsOld);
     60 
     61 static void BM_AssetManagerLoadFrameworkAssets(benchmark::State& state) {
     62   std::string path = kFrameworkPath;
     63   while (state.KeepRunning()) {
     64     std::unique_ptr<const ApkAssets> apk = ApkAssets::Load(path);
     65     AssetManager2 assets;
     66     assets.SetApkAssets({apk.get()});
     67   }
     68 }
     69 BENCHMARK(BM_AssetManagerLoadFrameworkAssets);
     70 
     71 static void BM_AssetManagerLoadFrameworkAssetsOld(benchmark::State& state) {
     72   String8 path(kFrameworkPath);
     73   while (state.KeepRunning()) {
     74     AssetManager assets;
     75     assets.addAssetPath(path, nullptr /* cookie */, false /* appAsLib */,
     76                         false /* isSystemAsset */);
     77 
     78     // Force creation.
     79     assets.getResources(true);
     80   }
     81 }
     82 BENCHMARK(BM_AssetManagerLoadFrameworkAssetsOld);
     83 
     84 static void BM_AssetManagerGetResource(benchmark::State& state, uint32_t resid) {
     85   GetResourceBenchmark({GetTestDataPath() + "/basic/basic.apk"}, nullptr /*config*/, resid, state);
     86 }
     87 BENCHMARK_CAPTURE(BM_AssetManagerGetResource, number1, basic::R::integer::number1);
     88 BENCHMARK_CAPTURE(BM_AssetManagerGetResource, deep_ref, basic::R::integer::deep_ref);
     89 
     90 static void BM_AssetManagerGetResourceOld(benchmark::State& state, uint32_t resid) {
     91   GetResourceBenchmarkOld({GetTestDataPath() + "/basic/basic.apk"}, nullptr /*config*/, resid,
     92                           state);
     93 }
     94 BENCHMARK_CAPTURE(BM_AssetManagerGetResourceOld, number1, basic::R::integer::number1);
     95 BENCHMARK_CAPTURE(BM_AssetManagerGetResourceOld, deep_ref, basic::R::integer::deep_ref);
     96 
     97 static void BM_AssetManagerGetLibraryResource(benchmark::State& state) {
     98   GetResourceBenchmark(
     99       {GetTestDataPath() + "/lib_two/lib_two.apk", GetTestDataPath() + "/lib_one/lib_one.apk",
    100        GetTestDataPath() + "/libclient/libclient.apk"},
    101       nullptr /*config*/, libclient::R::string::foo_one, state);
    102 }
    103 BENCHMARK(BM_AssetManagerGetLibraryResource);
    104 
    105 static void BM_AssetManagerGetLibraryResourceOld(benchmark::State& state) {
    106   GetResourceBenchmarkOld(
    107       {GetTestDataPath() + "/lib_two/lib_two.apk", GetTestDataPath() + "/lib_one/lib_one.apk",
    108        GetTestDataPath() + "/libclient/libclient.apk"},
    109       nullptr /*config*/, libclient::R::string::foo_one, state);
    110 }
    111 BENCHMARK(BM_AssetManagerGetLibraryResourceOld);
    112 
    113 constexpr static const uint32_t kStringOkId = 0x0104000au;
    114 
    115 static void BM_AssetManagerGetResourceFrameworkLocale(benchmark::State& state) {
    116   ResTable_config config;
    117   memset(&config, 0, sizeof(config));
    118   memcpy(config.language, "fr", 2);
    119   GetResourceBenchmark({kFrameworkPath}, &config, kStringOkId, state);
    120 }
    121 BENCHMARK(BM_AssetManagerGetResourceFrameworkLocale);
    122 
    123 static void BM_AssetManagerGetResourceFrameworkLocaleOld(benchmark::State& state) {
    124   ResTable_config config;
    125   memset(&config, 0, sizeof(config));
    126   memcpy(config.language, "fr", 2);
    127   GetResourceBenchmarkOld({kFrameworkPath}, &config, kStringOkId, state);
    128 }
    129 BENCHMARK(BM_AssetManagerGetResourceFrameworkLocaleOld);
    130 
    131 static void BM_AssetManagerGetBag(benchmark::State& state) {
    132   std::unique_ptr<const ApkAssets> apk = ApkAssets::Load(GetTestDataPath() + "/styles/styles.apk");
    133   if (apk == nullptr) {
    134     state.SkipWithError("Failed to load assets");
    135     return;
    136   }
    137 
    138   AssetManager2 assets;
    139   assets.SetApkAssets({apk.get()});
    140 
    141   while (state.KeepRunning()) {
    142     const ResolvedBag* bag = assets.GetBag(app::R::style::StyleTwo);
    143     const auto bag_end = end(bag);
    144     for (auto iter = begin(bag); iter != bag_end; ++iter) {
    145       uint32_t key = iter->key;
    146       Res_value value = iter->value;
    147       benchmark::DoNotOptimize(key);
    148       benchmark::DoNotOptimize(value);
    149     }
    150   }
    151 }
    152 BENCHMARK(BM_AssetManagerGetBag);
    153 
    154 static void BM_AssetManagerGetBagOld(benchmark::State& state) {
    155   AssetManager assets;
    156   if (!assets.addAssetPath(String8((GetTestDataPath() + "/styles/styles.apk").data()),
    157                            nullptr /*cookie*/, false /*appAsLib*/, false /*isSystemAssets*/)) {
    158     state.SkipWithError("Failed to load assets");
    159     return;
    160   }
    161 
    162   const ResTable& table = assets.getResources(true);
    163 
    164   while (state.KeepRunning()) {
    165     const ResTable::bag_entry* bag_begin;
    166     const ssize_t N = table.lockBag(app::R::style::StyleTwo, &bag_begin);
    167     const ResTable::bag_entry* const bag_end = bag_begin + N;
    168     for (auto iter = bag_begin; iter != bag_end; ++iter) {
    169       uint32_t key = iter->map.name.ident;
    170       Res_value value = iter->map.value;
    171       benchmark::DoNotOptimize(key);
    172       benchmark::DoNotOptimize(value);
    173     }
    174     table.unlockBag(bag_begin);
    175   }
    176 }
    177 BENCHMARK(BM_AssetManagerGetBagOld);
    178 
    179 static void BM_AssetManagerGetResourceLocales(benchmark::State& state) {
    180   std::unique_ptr<const ApkAssets> apk = ApkAssets::Load(kFrameworkPath);
    181   if (apk == nullptr) {
    182     state.SkipWithError("Failed to load assets");
    183     return;
    184   }
    185 
    186   AssetManager2 assets;
    187   assets.SetApkAssets({apk.get()});
    188 
    189   while (state.KeepRunning()) {
    190     std::set<std::string> locales =
    191         assets.GetResourceLocales(false /*exclude_system*/, true /*merge_equivalent_languages*/);
    192     benchmark::DoNotOptimize(locales);
    193   }
    194 }
    195 BENCHMARK(BM_AssetManagerGetResourceLocales);
    196 
    197 static void BM_AssetManagerGetResourceLocalesOld(benchmark::State& state) {
    198   AssetManager assets;
    199   if (!assets.addAssetPath(String8(kFrameworkPath), nullptr /*cookie*/, false /*appAsLib*/,
    200                            true /*isSystemAssets*/)) {
    201     state.SkipWithError("Failed to load assets");
    202     return;
    203   }
    204 
    205   const ResTable& table = assets.getResources(true);
    206 
    207   while (state.KeepRunning()) {
    208     Vector<String8> locales;
    209     table.getLocales(&locales, true /*includeSystemLocales*/, true /*mergeEquivalentLangs*/);
    210     benchmark::DoNotOptimize(locales);
    211   }
    212 }
    213 BENCHMARK(BM_AssetManagerGetResourceLocalesOld);
    214 
    215 static void BM_AssetManagerSetConfigurationFramework(benchmark::State& state) {
    216   std::unique_ptr<const ApkAssets> apk = ApkAssets::Load(kFrameworkPath);
    217   if (apk == nullptr) {
    218     state.SkipWithError("Failed to load assets");
    219     return;
    220   }
    221 
    222   AssetManager2 assets;
    223   assets.SetApkAssets({apk.get()});
    224 
    225   ResTable_config config;
    226   memset(&config, 0, sizeof(config));
    227 
    228   while (state.KeepRunning()) {
    229     config.sdkVersion = ~config.sdkVersion;
    230     assets.SetConfiguration(config);
    231   }
    232 }
    233 BENCHMARK(BM_AssetManagerSetConfigurationFramework);
    234 
    235 static void BM_AssetManagerSetConfigurationFrameworkOld(benchmark::State& state) {
    236   AssetManager assets;
    237   if (!assets.addAssetPath(String8(kFrameworkPath), nullptr /*cookie*/, false /*appAsLib*/,
    238                            true /*isSystemAssets*/)) {
    239     state.SkipWithError("Failed to load assets");
    240     return;
    241   }
    242 
    243   const ResTable& table = assets.getResources(true);
    244 
    245   ResTable_config config;
    246   memset(&config, 0, sizeof(config));
    247 
    248   while (state.KeepRunning()) {
    249     config.sdkVersion = ~config.sdkVersion;
    250     assets.setConfiguration(config);
    251   }
    252 }
    253 BENCHMARK(BM_AssetManagerSetConfigurationFrameworkOld);
    254 
    255 }  // namespace android
    256