Baseline Profile 安装时优化在西瓜视频的实践

private fun profmanGetProfileRules(apkPath: String, pathOptions: List<String>): String {
    // When compiling with CompilationMode.SpeedProfile, ART stores the profile in one of
    // 2 locations. The `ref` profile path, or the `current` path.
    // The `current` path is eventually merged  into the `ref` path after background dexopt.
    val profiles = pathOptions.mapNotNull { currentPath ->
        Log.d(TAG, "Using profile location: $currentPath")
        val profile = Shell.executeScriptCaptureStdout(
            "profman --dump-classes-and-methods --profile-file=$currentPath --apk=$apkPath"
        )
        profile.ifBlank { null }
    }
    ...
    return builder.toString()
}

adb shell profman --dump-classes-and-methods \
--profile-file=/data/misc/profiles/cur/0/com.ss.android.article.video/primary.prof \
--apk=/data/app/com.ss.android.article.video-Ctzj32dufeuXB8KOhAqdGg==/base.apk \
> baseline-prof.txt

PLcom/bytedance/apm/perf/b/f;->a(Lcom/bytedance/apm/perf/b/f;)Ljava/lang/String;
PLcom/bytedance/bdp/bdpbase/ipc/n$a;->a()Lcom/bytedance/bdp/bdpbase/ipc/n;
HSPLorg/android/spdy/SoInstallMgrSdk;->initSo(Ljava/lang/String;I)Z
HSPLorg/android/spdy/SpdyAgent;->InvlidCharJudge([B[B)V
Lanet/channel/e/a$b;
Lcom/bytedance/alliance/services/impl/c;
...

[FLAGS][CLASS_DESCRIPTOR]->[METHOD_SIGNATURE]

[CLASS_DESCRIPTOR]

/**
 * Task that transforms a human readable art profile into a binary form version that can be shipped
 * inside an APK or a Bundle.
 */
abstract class CompileArtProfileTask: NonIncrementalTask() {
...
    abstract class CompileArtProfileWorkAction:
            ProfileAwareWorkAction<CompileArtProfileWorkAction.Parameters>() {
        override fun run() {
            val diagnostics = Diagnostics {
                    error -> throw RuntimeException("Error parsing baseline-prof.txt : $error")
            }
            val humanReadableProfile = HumanReadableProfile(
                parameters.mergedArtProfile.get().asFile,
                diagnostics
            ) ?: throw RuntimeException(
                "Merged ${SdkConstants.FN_ART_PROFILE} cannot be parsed successfully."
            )

            val supplier = DexFileNameSupplier()
            val artProfile = ArtProfile(
                    humanReadableProfile,
                    if (parameters.obfuscationMappingFile.isPresent) {
                        ObfuscationMap(parameters.obfuscationMappingFile.get().asFile)
                    } else {
                        ObfuscationMap.Empty
                    },
                    //need to rename dex files with sequential numbers the same way [DexIncrementalRenameManager] does
                    parameters.dexFolders.asFileTree.files.sortedWith(DexFileComparator()).map {
                        DexFile(it.inputStream(), supplier.get())
                    }
            )
            // the P compiler is always used, the server side will transcode if necessary.
            parameters.binaryArtProfileOutputFile.get().asFile.outputStream().use {
                artProfile.save(it, ArtProfileSerializer.V0_1_0_P)
            }

            // create the metadata.
            parameters.binaryArtProfileMetadataOutputFile.get().asFile.outputStream().use {
                artProfile.save(it, ArtProfileSerializer.METADATA_0_0_2)
            }
        }
    }

val packageAndroidTask =
    variant.variantScope.taskContainer.packageAndroidTask?.get()
packageAndroidTask?.doFirst {
    var dexFiles = collectDexFiles(variant.packageApplication.dexFolders)
    dexFiles = dexFiles.sortedWith(DexFileComparator()) 
    //基准配置文件的内存表示
    var hrp = HumanReadableProfile("baseline-prof.txt")
    var obfFile: File? = getObfFile(variant, proguardTask)
    val apk = Apk(dexFiles, "")
    val obf =
        if (obfFile != null) ObfuscationMap(obfFile) else ObfuscationMap.Empty
    val profile = ArtProfile(hrp!!, obf, apk)
    val dexoptDir = File(variant.mergedAssets.first(), profDir)
    if (!dexoptDir.exists()) {
        dexoptDir.mkdirs()
    }
    val outFile = File(dexoptDir, "baseline.prof")
    val metaFile = File(dexoptDir, "baseline.profm")
    profile.save(outFile.outputStream(), ArtProfileSerializer.V0_1_0_P)
    profile.save(metaFile.outputStream(), ArtProfileSerializer.METADATA_0_0_2)
  }

InstallPackageHelper.java#installPackagesLI
    InstallPackageHelper.java#executePostCommitSteps
        ArtManagerService.java#prepareAppProfiles
            Installer.java#prepareAppProfile
                InstalldNativeService.cpp#prepareAppProfile
                    dexopt.cpp#prepare_app_profile
                        ProfileAssistant.cpp#ProcessProfilesInternal
        PackageDexOptimizer.java#performDexOpt
            PackageDexOptimizer.java#performDexOptLI
               PackageDexOptimizer.java#dexOptPath
                   InstalldNativeService.cpp#dexopt
                       dexopt.cpp#dexopt
                           dex2oat.cc

private void installPackagesLI(List<InstallRequest> requests) {
         //阶段1：prepare
         prepareResult = preparePackageLI(request.mArgs, request.mInstallResult);
         //阶段2：scan
         final ScanResult result = scanPackageTracedLI(
                            prepareResult.mPackageToScan, prepareResult.mParseFlags,
                            prepareResult.mScanFlags, System.currentTimeMillis(),
                            request.mArgs.mUser, request.mArgs.mAbiOverride);
         //阶段3：Reconcile
         reconciledPackages = ReconcilePackageUtils.reconcilePackages(
                            reconcileRequest, mSharedLibraries,
                            mPm.mSettings.getKeySetManagerService(), mPm.mSettings);
         //阶段4：Commit并安装
         commitRequest = new CommitRequest(reconciledPackages,
                            mPm.mUserManager.getUserIds()); 
         executePostCommitSteps(commitRequest);            
    }

private void executePostCommitSteps(CommitRequest commitRequest) {
        for (ReconciledPackage reconciledPkg : commitRequest.mReconciledPackages.values()) {
            final AndroidPackage pkg = reconciledPkg.mPkgSetting.getPkg();
            final String packageName = pkg.getPackageName();
            final String codePath = pkg.getPath();
             //步骤1：prof文件写入
            // Prepare the application profiles for the new code paths.
            // This needs to be done before invoking dexopt so that any install-time profile
            // can be used for optimizations.
            mArtManagerService.prepareAppProfiles(pkg,
                    mPm.resolveUserIds(reconciledPkg.mInstallArgs.mUser.getIdentifier()),
                    /* updateReferenceProfileCnotallow= */ true);
             //步骤2：dex优化，在开启baseline profile优化之后compilation-reasnotallow=install-dm
            final int compilationReason =
                    mDexManager.getCompilationReasonForInstallScenario(
                            reconciledPkg.mInstallArgs.mInstallScenario);
            DexoptOptions dexoptOptions =
                    new DexoptOptions(packageName, compilationReason, dexoptFlags);
            if (performDexopt) {
                // Compile the layout resources.
                if (SystemProperties.getBoolean(PRECOMPILE_LAYOUTS, false)) {
                    mViewCompiler.compileLayouts(pkg);
                }
                ScanResult result = reconciledPkg.mScanResult;
                mPackageDexOptimizer.performDexOpt(pkg, realPkgSetting,
                        null /* instructionSets */,
                        mPm.getOrCreateCompilerPackageStats(pkg),
                        mDexManager.getPackageUseInfoOrDefault(packageName),
                        dexoptOptions);
            }
            // Notify BackgroundDexOptService that the package has been changed.
            // If this is an update of a package which used to fail to compile,
            // BackgroundDexOptService will remove it from its denylist.
            BackgroundDexOptService.getService().notifyPackageChanged(packageName);
            notifyPackageChangeObserversOnUpdate(reconciledPkg);
        }
        PackageManagerServiceUtils.waitForNativeBinariesExtractionForIncremental(
                incrementalStorages);
    }

/**
     * Prepare the application profiles.
     *   - create the current primary profile to save time at app startup time.
     *   - copy the profiles from the associated dex metadata file to the reference profile.
     */
    public void prepareAppProfiles(
            AndroidPackage pkg, @UserIdInt int user,
            boolean updateReferenceProfileContent) {
        try {
            ArrayMap<String, String> codePathsProfileNames = getPackageProfileNames(pkg);
            for (int i = codePathsProfileNames.size() - 1; i >= 0; i--) {
                String codePath = codePathsProfileNames.keyAt(i);
                String profileName = codePathsProfileNames.valueAt(i);
                String dexMetadataPath = null;
                // Passing the dex metadata file to the prepare method will update the reference
                // profile content. As such, we look for the dex metadata file only if we need to
                // perform an update.
                if (updateReferenceProfileContent) {
                    File dexMetadata = DexMetadataHelper.findDexMetadataForFile(new File(codePath));
                    dexMetadataPath = dexMetadata == null ? null : dexMetadata.getAbsolutePath();
                }
                synchronized (mInstaller) {
                    boolean result = mInstaller.prepareAppProfile(pkg.getPackageName(), user, appId,
                            profileName, codePath, dexMetadataPath);
                }
            }
        } catch (InstallerException e) {
        }
    }

//frameworks/native/cmds/installd/dexopt.cpp
bool prepare_app_profile(const std::string& package_name,
                         userid_t user_id,
                         appid_t app_id,
                         const std::string& profile_name,
                         const std::string& code_path,
                         const std::optional<std::string>& dex_metadata) {

    // We have a dex metdata. Merge the profile into the reference profile.
    unique_fd ref_profile_fd =
            open_reference_profile(multiuser_get_uid(user_id, app_id), package_name, profile_name,
                                   /*read_write*/ true, /*is_secondary_dex*/ false);
    unique_fd dex_metadata_fd(TEMP_FAILURE_RETRY(
            open(dex_metadata->c_str(), O_RDONLY | O_NOFOLLOW)));
    unique_fd apk_fd(TEMP_FAILURE_RETRY(open(code_path.c_str(), O_RDONLY | O_NOFOLLOW)));
    RunProfman args;
    args.SetupCopyAndUpdate(dex_metadata_fd,
                            ref_profile_fd,
                            apk_fd,
                            code_path);
    pid_t pid = fork();
    if (pid == 0) {
        args.Exec();
    }
    return true;
}
    void SetupCopyAndUpdate(const unique_fd& profile_fd,
                            const unique_fd& reference_profile_fd,
                            const unique_fd& apk_fd,
                            const std::string& dex_location) {
        SetupArgs(...);
    }
    void SetupArgs(const std::vector<T>& profile_fds,
                   const unique_fd& reference_profile_fd,
                   const std::vector<U>& apk_fds,
                   const std::vector<std::string>& dex_locations,
                   bool copy_and_update,
                   bool for_snapshot,
                   bool for_boot_image) {
        const char* profman_bin = select_execution_binary("/profman");
        if (reference_profile_fd != -1) {
            AddArg("--reference-profile-file-fd=" + std::to_string(reference_profile_fd.get()));
        }
        for (const T& fd : profile_fds) {
            AddArg("--profile-file-fd=" + std::to_string(fd.get()));
        }
        for (const U& fd : apk_fds) {
            AddArg("--apk-fd=" + std::to_string(fd.get()));
        }
        for (const std::string& dex_location : dex_locations) {
            AddArg("--dex-locatinotallow=" + dex_location);
        }
        ...
}

./profman --reference-profile-file-fd=9 \
--profile-file-fd=10 --apk-fd=11 \
--dex-locatinotallow=/data/app/com.ss.android.article.video-4-JZaMrtO7n_kFe4kbhBBA==/base.apk \
--copy-and-update-profile-key

class ProfMan final {
 public:
  void ParseArgs(int argc, char **argv) {
    MemMap::Init();

    for (int i = 0; i < argc; ++i) {
      if (StartsWith(option, "--profile-file=")) {
        profile_files_.push_back(std::string(option.substr(strlen("--profile-file="))));
      } else if (StartsWith(option, "--profile-file-fd=")) {
        ParseFdForCollection(raw_option, "--profile-file-fd=", &profile_files_fd_);
      } else if (StartsWith(option, "--dex-locatinotallow=")) {
        dex_locations_.push_back(std::string(option.substr(strlen("--dex-locatinotallow="))));
      } else if (StartsWith(option, "--apk-fd=")) {
        ParseFdForCollection(raw_option, "--apk-fd=", &apks_fd_);
      } else if (StartsWith(option, "--apk=")) {
        apk_files_.push_back(std::string(option.substr(strlen("--apk="))));
      } 
      ...
  }
 static int profman(int argc, char** argv) {
  ProfMan profman;
  // Parse arguments. Argument mistakes will lead to exit(EXIT_FAILURE) in UsageError.
  profman.ParseArgs(argc, argv);
  // Initialize MemMap for ZipArchive::OpenFromFd.
  MemMap::Init(); 
  ...
   // Process profile information and assess if we need to do a profile guided compilation.
  // This operation involves I/O.
  return profman.ProcessProfiles();
  }

ProfmanResult::ProcessingResult ProfileAssistant::ProcessProfilesInternal(
    const std::vector<ScopedFlock>& profile_files,
    const ScopedFlock& reference_profile_file,
    const ProfileCompilationInfo::ProfileLoadFilterFn& filter_fn,
    const Options& options) {
  ProfileCompilationInfo info(options.IsBootImageMerge());
  //步骤1：Load the reference profile.
  if (!info.Load(reference_profile_file->Fd(), true, filter_fn)) {
    return ProfmanResult::kErrorBadProfiles;
  }
   // Store the current state of the reference profile before merging with the current profiles.
   uint32_t number_of_methods = info.GetNumberOfMethods();
   uint32_t number_of_classes = info.GetNumberOfResolvedClasses();

  //步骤2：Merge all current profiles.
  for (size_t i = 0; i < profile_files.size(); i++) {
    ProfileCompilationInfo cur_info(options.IsBootImageMerge());
    if (!cur_info.Load(profile_files[i]->Fd(), /*merge_classes=*/ true, filter_fn)) {
      return ProfmanResult::kErrorBadProfiles;
    }
    if (!info.MergeWith(cur_info)) {
      return ProfmanResult::kErrorBadProfiles;
    }
  }
  // 如果新增方法/类没有达到阈值，则跳过
 if (((info.GetNumberOfMethods() - number_of_methods) < min_change_in_methods_for_compilation) 
     && ((info.GetNumberOfResolvedClasses() - number_of_classes) < min_change_in_classes_for_compilation)) {
      return kSkipCompilation;
   }
  ...
    //步骤3：We were successful in merging all profile information. Update the reference profile.
  ...
  if (!info.Save(reference_profile_file->Fd())) {
    return ProfmanResult::kErrorIO;
  }  
  return options.IsForceMerge() ? ProfmanResult::kSuccess : ProfmanResult::kCompile;
}

//art/libprofile/profile/profile_compilation_info.h
/**
 * Profile information in a format suitable to be queried by the compiler and
 * performing profile guided compilation.
 * It is a serialize-friendly format based on information collected by the
 * interpreter (ProfileInfo).
 * Currently it stores only the hot compiled methods.
 */
class ProfileCompilationInfo {
 public:
  static const uint8_t kProfileMagic[];
  static const uint8_t kProfileVersion[];
  static const uint8_t kProfileVersionForBootImage[];
  static const char kDexMetadataProfileEntry[];

  static constexpr size_t kProfileVersionSize = 4;
  static constexpr uint8_t kIndividualInlineCacheSize = 5;
  ...
 }

//dexopt.cpp
int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* instruction_set,
        int dexopt_needed, const char* oat_dir, int dexopt_flags, const char* compiler_filter,
        const char* volume_uuid, const char* class_loader_context, const char* se_info,
        bool downgrade, int target_sdk_version, const char* profile_name,
        const char* dex_metadata_path, const char* compilation_reason, std::string* error_msg,
        /* out */ bool* completed) {
    ...    
    RunDex2Oat runner(dex2oat_bin, execv_helper.get());
    runner.Initialize(...);

    bool cancelled = false;
    pid_t pid = dexopt_status_->check_cancellation_and_fork(&cancelled);
    if (cancelled) {
        *completed = false;
        return 0;
    }
    if (pid == 0) {
        //设置schedpolicy，设置为后台线程
        SetDex2OatScheduling(boot_complete);
        //执行dex2oat命令
        runner.Exec(DexoptReturnCodes::kDex2oatExec);
    } else {
        //父进程等待dex2oat子进程执行完,超时时间9.5分钟.
        int res = wait_child_with_timeout(pid, kLongTimeoutMs);
        if (res == 0) {
            LOG(VERBOSE) << "DexInv: --- END '" << dex_path << "' (success) ---";
        } else {
            //dex2oat执行失败
        }
    }
    // dex2oat ran successfully, so profile is safe to keep.
    reference_profile.DisableCleanup();
    return 0;
}

/apex/com.android.runtime/bin/dex2oat \
--input-vdex-fd=-1 --output-vdex-fd=11 \
--resolve-startup-const-strings=true \
--max-image-block-size=524288 --compiler-filter=speed-profile --profile-file-fd=14 \
--classpath-dir=/data/app/com.ss.android.article.video-4-JZaMrtO7n_kFe4kbhBBA== \
--class-loader-context=PCL[]{PCL[/system/framework/org.apache.http.legacy.jar]} \
--generate-mini-debug-info --compact-dex-level=none --dm-fd=15 \
--compilation-reasnotallow=install-dm

static dex2oat::ReturnCode Dex2oat(int argc, char** argv) {
  TimingLogger timings("compiler", false, false);
  // 解析参数
  dex2oat->ParseArgs(argc, argv);
  art::MemMap::Init(); 
  // 加载profile热点方法文件
  if (dex2oat->HasProfileInput()) {
    if (!dex2oat->LoadProfile()) {
      return dex2oat::ReturnCode::kOther;
    }
  }
  //打开输入文件
  dex2oat->OpenFile();
  //准备de2oat环境，包括启动runtime、加载boot class path
  dex2oat::ReturnCode setup_code = dex2oat->Setup();

   //检查profile热点方法是否被加载到内存，并做crc校验
  if (dex2oat->DoProfileGuidedOptimizations()) { 
    //校验profile_compilation_info_中dex的crc与apk中dex的crc是否一致
    dex2oat->VerifyProfileData();
  }
  ...  
  //正式开始编译
  dex2oat::ReturnCode result = DoCompilation(*dex2oat);
  ...  
  return result;
}

bool LoadProfile() {
    //初始化profile热点方法的内存对象：profile_compilation_info_
    profile_compilation_info_.reset(new ProfileCompilationInfo());

    //读取reference profile文件列表
    // Dex2oat only uses the reference profile and that is not updated concurrently by the app or
    // other processes. So we don't need to lock (as we have to do in profman or when writing the
    // profile info).
    std::vector<std::unique_ptr<File>> profile_files;
    if (!profile_file_fds_.empty()) {
      for (int fd : profile_file_fds_) {
        profile_files.push_back(std::make_unique<File>(DupCloexec(fd)));
      }
    } 
    ...
    //依次加载到profile_compilation_info_中
    for (const std::unique_ptr<File>& profile_file : profile_files) {
      if (!profile_compilation_info_->Load(profile_file->Fd())) {
        return false;
      }
    }
    return true;
  }

// Set up and create the compiler driver and then invoke it to compile all the dex files.
  jobject Compile() REQUIRES(!Locks::mutator_lock_) {
    ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
    
    TimingLogger::ScopedTiming t("dex2oat Compile", timings_);
    ...
    compiler_options_->profile_compilation_info_ = profile_compilation_info_.get();

    driver_.reset(new CompilerDriver(compiler_options_.get(),
                                     verification_results_.get(),
                                     compiler_kind_,
                                     thread_count_,
                                     swap_fd_));
    driver_->PrepareDexFilesForOatFile(timings_);
    return CompileDexFiles(dex_files);
  }

void CompilerDriver::Compile(jobject class_loader,
                             const std::vector<const DexFile*>& dex_files,
                             TimingLogger* timings) {
  for (const DexFile* dex_file : dex_files) {
    CompileDexFile(this,class_loader,*dex_file,dex_files,
                   "Compile Dex File Quick",CompileMethodQuick);
  }
}

static void CompileMethodQuick(...) {
  auto quick_fn = [profile_index](...) {
    CompiledMethod* compiled_method = nullptr;
    if ((access_flags & kAccNative) != 0) {
        //jni方法编译...
    } else if ((access_flags & kAccAbstract) != 0) {
      // Abstract methods don't have code.
    } else if (annotations::MethodIsNeverCompile(dex_file,
                                                 dex_file.GetClassDef(class_def_idx),
                                                 method_idx)) {
      // Method is annotated with @NeverCompile and should not be compiled.
    } else {
      const CompilerOptions& compiler_options = driver->GetCompilerOptions();
      const VerificationResults* results = driver->GetVerificationResults();
      MethodReference method_ref(&dex_file, method_idx);
      // Don't compile class initializers unless kEverything.
      bool compile = (compiler_options.GetCompilerFilter() == CompilerFilter::kEverything) ||
         ((access_flags & kAccConstructor) == 0) || ((access_flags & kAccStatic) == 0);
      // Check if it's an uncompilable method found by the verifier.
      compile = compile && !results->IsUncompilableMethod(method_ref);
      // Check if we should compile based on the profile.
      compile = compile && ShouldCompileBasedOnProfile(compiler_options, profile_index, method_ref);
      if (compile) {
        compiled_method = driver->GetCompiler()->Compile(...);
      }
    }
    return compiled_method;
  };
  CompileMethodHarness(self,driver,code_item,access_flags,
                       invoke_type,class_def_idx,class_loader,
                       dex_file,dex_cache,quick_fn);
}

// Checks whether profile guided compilation is enabled and if the method should be compiled
// according to the profile file.
static bool ShouldCompileBasedOnProfile(const CompilerOptions& compiler_options,
                                        ProfileCompilationInfo::ProfileIndexType profile_index,
                                        MethodReference method_ref) {
  if (profile_index == ProfileCompilationInfo::MaxProfileIndex()) {
    // No profile for this dex file. Check if we're actually compiling based on a profile.
    if (!CompilerFilter::DependsOnProfile(compiler_options.GetCompilerFilter())) {
      return true;
    }
    // Profile-based compilation without profile for this dex file. Do not compile the method.
    return false;
  } else {
    const ProfileCompilationInfo* profile_compilation_info =
        compiler_options.GetProfileCompilationInfo();

    // Compile only hot methods, it is the profile saver's job to decide
    // what startup methods to mark as hot.
    bool result = profile_compilation_info->IsHotMethod(profile_index, method_ref.index);
   if (kDebugProfileGuidedCompilation) {
      LOG(INFO) << "[ProfileGuidedCompilation] "
          << (result ? "Compiled" : "Skipped") << " method:" << method_ref.PrettyMethod(true);
    }
    return result;
  }
}

//art/compiler/optimizing/code_generator.cc
void CodeGenerator::Compile(CodeAllocator* allocator) {
  InitializeCodeGenerationData();
  HGraphVisitor* instruction_visitor = GetInstructionVisitor();
  GetStackMapStream()->BeginMethod(...);
  size_t frame_start = GetAssembler()->CodeSize();
  GenerateFrameEntry();
  if (disasm_info_ != nullptr) {
    disasm_info_->SetFrameEntryInterval(frame_start, GetAssembler()->CodeSize());
  }
  for (size_t e = block_order_->size(); current_block_index_ < e; ++current_block_index_) {
    HBasicBlock* block = (*block_order_)[current_block_index_];
    Bind(block);
    MaybeRecordNativeDebugInfo(/* instructinotallow= */ nullptr, block->GetDexPc());
    for (HInstructionIterator it(block->GetInstructions()); !it.Done(); it.Advance()) {
      HInstruction* current = it.Current();
      DisassemblyScope disassembly_scope(current, *this);
      current->Accept(instruction_visitor);
    }
  }
  GenerateSlowPaths();
  if (graph_->HasTryCatch()) {
    RecordCatchBlockInfo();
  }
  // Finalize instructions in assember;
  Finalize(allocator);
  GetStackMapStream()->EndMethod(GetAssembler()->CodeSize());
}

class OatWriter {
 public:
  OatWriter(const CompilerOptions& compiler_options,
            const VerificationResults* verification_results,
            TimingLogger* timings,
            ProfileCompilationInfo* info,
            CompactDexLevel compact_dex_level);
  ...          
  // Profile info used to generate new layout of files.
  ProfileCompilationInfo* profile_compilation_info_;

  // Compact dex level that is generated.
  CompactDexLevel compact_dex_level_;
  using OrderedMethodList = std::vector<OrderedMethodData>;
  ...

// Visit every compiled method in order to determine its order within the OAT file.
// Methods from the same class do not need to be adjacent in the OAT code.
class OatWriter::LayoutCodeMethodVisitor final : public OatDexMethodVisitor {
 public:
  LayoutCodeMethodVisitor(OatWriter* writer, size_t offset)
      : OatDexMethodVisitor(writer, offset),
        profile_index_(ProfileCompilationInfo::MaxProfileIndex()),
        profile_index_dex_file_(nullptr) {
  }

  bool StartClass(const DexFile* dex_file, size_t class_def_index) final {
    // Update the cached `profile_index_` if needed. This happens only once per dex file
    // because we visit all classes in a dex file together, so mark that as `UNLIKELY`.
    if (UNLIKELY(dex_file != profile_index_dex_file_)) {
      if (writer_->profile_compilation_info_ != nullptr) {
        profile_index_ = writer_->profile_compilation_info_->FindDexFile(*dex_file);
      }
      profile_index_dex_file_ = dex_file;
    }
    return OatDexMethodVisitor::StartClass(dex_file, class_def_index);
  }
  bool VisitMethod(size_t class_def_method_index, const ClassAccessor::Method& method){
    OatClass* oat_class = &writer_->oat_classes_[oat_class_index_];
    CompiledMethod* compiled_method = oat_class->GetCompiledMethod(class_def_method_index);

    if (HasCompiledCode(compiled_method)) {
      // Determine the `hotness_bits`, used to determine relative order
      // for OAT code layout when determining binning.
      uint32_t method_index = method.GetIndex();
      MethodReference method_ref(dex_file_, method_index);
      uint32_t hotness_bits = 0u;
      if (profile_index_ != ProfileCompilationInfo::MaxProfileIndex()) {
        ProfileCompilationInfo* pci = writer_->profile_compilation_info_;
        // Note: Bin-to-bin order does not matter. If the kernel does or does not read-ahead
        // any memory, it only goes into the buffer cache and does not grow the PSS until the
        // first time that memory is referenced in the process.
        hotness_bits =
            (pci->IsHotMethod(profile_index_, method_index) ? kHotBit : 0u) |
            (pci->IsStartupMethod(profile_index_, method_index) ? kStartupBit : 0u) 
        }
      }
      OrderedMethodData method_data = {hotness_bits,oat_class,compiled_method,method_ref,...};
      ordered_methods_.push_back(method_data);
    }
    return true;
  }

java.io.FileNotFoundException: 
This file can not be opened as a file descriptor; it is probably compressed

private void writeNoCompress(@NonNull JarEntry entry, @NonNull InputStream from) throws IOException {
    byte[] bytes = new byte[from.available()];
    from.read(bytes);
    entry.setMethod(JarEntry.STORED);
    entry.setSize(bytes.length);
    CRC32 crc32 = new CRC32();
    crc32.update(bytes,0,bytes.length);
    entry.setCrc(crc32.getValue());
    setEntryAttributes(entry);
    jarOutputStream.putNextEntry(entry);
    jarOutputStream.write(bytes, 0, bytes.length);
    jarOutputStream.closeEntry();
}

# Unzip the Release APK first
unzip release.apk
# Create a ZIP archive
cp assets/dexopt/baseline.prof primary.prof
cp assets/dexopt/baseline.profm primary.profm
# Create an archive
zip -r release.dm primary.prof primary.profm
# Install APK + Profile together
adb install-multiple release.apk release.dm

PACKAGE_NAME=com.ss.android.article.video
adb shell am start-activity -W -n $PACKAGE_NAME/.SplashActivity | grep "TotalTime"