dex2oat/dex2oat_image_test.cc - platform/art - Gitiles

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <regex>
 #include <sstream>
 #include <string>
 #include <vector>

 #include <sys/wait.h>
 #include <unistd.h>

 #include <android-base/logging.h>

 #include "common_runtime_test.h"

 #include "base/file_utils.h"
 #include "base/macros.h"
 #include "base/unix_file/fd_file.h"
 #include "base/utils.h"
 #include "dex/art_dex_file_loader.h"
 #include "dex/dex_file-inl.h"
 #include "dex/dex_file_loader.h"
 #include "dex/method_reference.h"
 #include "profile/profile_compilation_info.h"
 #include "runtime.h"

 namespace art {

 struct ImageSizes {
   size_t art_size = 0;
   size_t oat_size = 0;
   size_t vdex_size = 0;
 };

 std::ostream& operator<<(std::ostream& os, const ImageSizes& sizes) {
   os << "art=" << sizes.art_size << " oat=" << sizes.oat_size << " vdex=" << sizes.vdex_size;
   return os;
 }

 class Dex2oatImageTest : public CommonRuntimeTest {
  public:
   virtual void TearDown() OVERRIDE {}

  protected:
   // Visitors take method and type references
   template <typename MethodVisitor, typename ClassVisitor>
   void VisitLibcoreDexes(const MethodVisitor& method_visitor,
                          const ClassVisitor& class_visitor,
                          size_t method_frequency = 1,
                          size_t class_frequency = 1) {
     size_t method_counter = 0;
     size_t class_counter = 0;
     for (const std::string& dex : GetLibCoreDexFileNames()) {
       std::vector<std::unique_ptr<const DexFile>> dex_files;
       std::string error_msg;
       const ArtDexFileLoader dex_file_loader;
       CHECK(dex_file_loader.Open(dex.c_str(),
                                  dex,
                                  /*verify*/ true,
                                  /*verify_checksum*/ false,
                                  &error_msg,
                                  &dex_files))
           << error_msg;
       for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
         for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) {
           if (++method_counter % method_frequency == 0) {
             method_visitor(MethodReference(dex_file.get(), i));
           }
         }
         for (size_t i = 0; i < dex_file->NumTypeIds(); ++i) {
           if (++class_counter % class_frequency == 0) {
             class_visitor(TypeReference(dex_file.get(), dex::TypeIndex(i)));
           }
         }
       }
     }
   }

   static void WriteLine(File* file, std::string line) {
     line += '\n';
     EXPECT_TRUE(file->WriteFully(&line[0], line.length()));
   }

   void GenerateClasses(File* out_file, size_t frequency = 1) {
     VisitLibcoreDexes(VoidFunctor(),
                       [out_file](TypeReference ref) {
       WriteLine(out_file, ref.dex_file->PrettyType(ref.TypeIndex()));
     }, frequency, frequency);
     EXPECT_EQ(out_file->Flush(), 0);
   }

   void GenerateMethods(File* out_file, size_t frequency = 1) {
     VisitLibcoreDexes([out_file](MethodReference ref) {
       WriteLine(out_file, ref.PrettyMethod());
     }, VoidFunctor(), frequency, frequency);
     EXPECT_EQ(out_file->Flush(), 0);
   }

   void AddRuntimeArg(std::vector<std::string>& args, const std::string& arg) {
     args.push_back("--runtime-arg");
     args.push_back(arg);
   }

   ImageSizes CompileImageAndGetSizes(const std::vector<std::string>& extra_args) {
     ImageSizes ret;
     ScratchFile scratch;
     std::string scratch_dir = scratch.GetFilename();
     while (!scratch_dir.empty() && scratch_dir.back() != '/') {
       scratch_dir.pop_back();
     }
     CHECK(!scratch_dir.empty()) << "No directory " << scratch.GetFilename();
     std::string error_msg;
     if (!CompileBootImage(extra_args, scratch.GetFilename(), &error_msg)) {
       LOG(ERROR) << "Failed to compile image " << scratch.GetFilename() << error_msg;
     }
     std::string art_file = scratch.GetFilename() + ".art";
     std::string oat_file = scratch.GetFilename() + ".oat";
     std::string vdex_file = scratch.GetFilename() + ".vdex";
     int64_t art_size = OS::GetFileSizeBytes(art_file.c_str());
     int64_t oat_size = OS::GetFileSizeBytes(oat_file.c_str());
     int64_t vdex_size = OS::GetFileSizeBytes(vdex_file.c_str());
     CHECK_GT(art_size, 0u) << art_file;
     CHECK_GT(oat_size, 0u) << oat_file;
     CHECK_GT(vdex_size, 0u) << vdex_file;
     ret.art_size = art_size;
     ret.oat_size = oat_size;
     ret.vdex_size = vdex_size;
     scratch.Close();
     // Clear image files since we compile the image multiple times and don't want to leave any
     // artifacts behind.
     ClearDirectory(scratch_dir.c_str(), /*recursive*/ false);
     return ret;
   }

   bool CompileBootImage(const std::vector<std::string>& extra_args,
                         const std::string& image_file_name_prefix,
                         std::string* error_msg) {
     Runtime* const runtime = Runtime::Current();
     std::vector<std::string> argv;
     argv.push_back(runtime->GetCompilerExecutable());
     AddRuntimeArg(argv, "-Xms64m");
     AddRuntimeArg(argv, "-Xmx64m");
     std::vector<std::string> dex_files = GetLibCoreDexFileNames();
     for (const std::string& dex_file : dex_files) {
       argv.push_back("--dex-file=" + dex_file);
       argv.push_back("--dex-location=" + dex_file);
     }
     if (runtime->IsJavaDebuggable()) {
       argv.push_back("--debuggable");
     }
     runtime->AddCurrentRuntimeFeaturesAsDex2OatArguments(&argv);

     AddRuntimeArg(argv, "-Xverify:softfail");

     if (!kIsTargetBuild) {
       argv.push_back("--host");
     }

     argv.push_back("--image=" + image_file_name_prefix + ".art");
     argv.push_back("--oat-file=" + image_file_name_prefix + ".oat");
     argv.push_back("--oat-location=" + image_file_name_prefix + ".oat");
     argv.push_back("--base=0x60000000");

     std::vector<std::string> compiler_options = runtime->GetCompilerOptions();
     argv.insert(argv.end(), compiler_options.begin(), compiler_options.end());

     // We must set --android-root.
     const char* android_root = getenv("ANDROID_ROOT");
     CHECK(android_root != nullptr);
     argv.push_back("--android-root=" + std::string(android_root));
     argv.insert(argv.end(), extra_args.begin(), extra_args.end());

     return RunDex2Oat(argv, error_msg);
   }

   int RunDex2Oat(const std::vector<std::string>& args, std::string* error_msg) {
     int link[2];

     if (pipe(link) == -1) {
       return false;
     }

     pid_t pid = fork();
     if (pid == -1) {
       return false;
     }

     if (pid == 0) {
       // We need dex2oat to actually log things.
       setenv("ANDROID_LOG_TAGS", "*:f", 1);
       dup2(link[1], STDERR_FILENO);
       close(link[0]);
       close(link[1]);
       std::vector<const char*> c_args;
       for (const std::string& str : args) {
         c_args.push_back(str.c_str());
       }
       c_args.push_back(nullptr);
       execv(c_args[0], const_cast<char* const*>(c_args.data()));
       exit(1);
       UNREACHABLE();
     } else {
       close(link[1]);
       char buffer[128];
       memset(buffer, 0, 128);
       ssize_t bytes_read = 0;

       while (TEMP_FAILURE_RETRY(bytes_read = read(link[0], buffer, 128)) > 0) {
         *error_msg += std::string(buffer, bytes_read);
       }
       close(link[0]);
       int status = -1;
       if (waitpid(pid, &status, 0) != -1) {
         return (status == 0);
       }
       return false;
     }
   }
 };

 TEST_F(Dex2oatImageTest, TestModesAndFilters) {
   if (kIsTargetBuild) {
     // This test is too slow for target builds.
     return;
   }
   ImageSizes base_sizes = CompileImageAndGetSizes({});
   ImageSizes image_classes_sizes;
   ImageSizes compiled_classes_sizes;
   ImageSizes compiled_methods_sizes;
   ImageSizes profile_sizes;
   std::cout << "Base compile sizes " << base_sizes << std::endl;
   // Test image classes
   {
     ScratchFile classes;
     GenerateClasses(classes.GetFile(), /*frequency*/ 1u);
     image_classes_sizes = CompileImageAndGetSizes(
         {"--image-classes=" + classes.GetFilename()});
     classes.Close();
     std::cout << "Image classes sizes " << image_classes_sizes << std::endl;
     // Putting all classes as image classes should increase art size
     EXPECT_GE(image_classes_sizes.art_size, base_sizes.art_size);
     // Sanity check that dex is the same size.
     EXPECT_EQ(image_classes_sizes.vdex_size, base_sizes.vdex_size);
   }
   // Test compiled classes.
   {
     ScratchFile classes;
     // Only compile every even class.
     GenerateClasses(classes.GetFile(), /*frequency*/ 2u);
     compiled_classes_sizes = CompileImageAndGetSizes(
         {"--image-classes=" + classes.GetFilename()});
     classes.Close();
     std::cout << "Compiled classes sizes " << compiled_classes_sizes << std::endl;
     // Art file should be smaller than image classes version since we included fewer classes in the
     // list.
     EXPECT_LT(compiled_classes_sizes.art_size, image_classes_sizes.art_size);
   }
   static size_t kMethodFrequency = 3;
   static size_t kTypeFrequency = 4;
   // Test compiling fewer methods and classes.
   {
     ScratchFile classes;
     // Only compile every even class.
     GenerateClasses(classes.GetFile(), kTypeFrequency);
     compiled_methods_sizes = CompileImageAndGetSizes(
         {"--image-classes=" + classes.GetFilename()});
     classes.Close();
     std::cout << "Compiled fewer methods sizes " << compiled_methods_sizes << std::endl;
   }
   // Cross verify profile based image against image-classes and compiled-methods to make sure it
   // matches.
   {
     ProfileCompilationInfo profile;
     VisitLibcoreDexes([&profile](MethodReference ref) {
       uint32_t flags = ProfileCompilationInfo::MethodHotness::kFlagHot |
           ProfileCompilationInfo::MethodHotness::kFlagStartup;
       EXPECT_TRUE(profile.AddMethodIndex(
           static_cast<ProfileCompilationInfo::MethodHotness::Flag>(flags),
           ref));
     }, [&profile](TypeReference ref) {
       EXPECT_TRUE(profile.AddClassForDex(ref));
     }, kMethodFrequency, kTypeFrequency);
     ScratchFile profile_file;
     profile.Save(profile_file.GetFile()->Fd());
     EXPECT_EQ(profile_file.GetFile()->Flush(), 0);
     profile_sizes = CompileImageAndGetSizes(
         {"--profile-file=" + profile_file.GetFilename(),
          "--compiler-filter=speed-profile"});
     profile_file.Close();
     std::cout << "Profile sizes " << profile_sizes << std::endl;
     // Since there is some difference between profile vs image + methods due to layout, check that
     // the range is within expected margins (+-10%).
     const double kRatio = 0.90;
     EXPECT_LE(profile_sizes.art_size * kRatio, compiled_methods_sizes.art_size);
     // TODO(mathieuc): Find a reliable way to check compiled code. b/63746626
     // EXPECT_LE(profile_sizes.oat_size * kRatio, compiled_methods_sizes.oat_size);
     EXPECT_LE(profile_sizes.vdex_size * kRatio, compiled_methods_sizes.vdex_size);
     EXPECT_GE(profile_sizes.art_size / kRatio, compiled_methods_sizes.art_size);
     // TODO(mathieuc): Find a reliable way to check compiled code. b/63746626
     // EXPECT_GE(profile_sizes.oat_size / kRatio, compiled_methods_sizes.oat_size);
     EXPECT_GE(profile_sizes.vdex_size / kRatio, compiled_methods_sizes.vdex_size);
   }
   // Test dirty image objects.
   {
     ScratchFile classes;
     GenerateClasses(classes.GetFile(), /*frequency*/ 1u);
     image_classes_sizes = CompileImageAndGetSizes(
         {"--dirty-image-objects=" + classes.GetFilename()});
     classes.Close();
     std::cout << "Dirty image object sizes " << image_classes_sizes << std::endl;
   }
 }

 }  // namespace art
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <regex>
	#include <sstream>
	#include <string>
	#include <vector>

	#include <sys/wait.h>
	#include <unistd.h>

	#include <android-base/logging.h>

	#include "common_runtime_test.h"

	#include "base/file_utils.h"
	#include "base/macros.h"
	#include "base/unix_file/fd_file.h"
	#include "base/utils.h"
	#include "dex/art_dex_file_loader.h"
	#include "dex/dex_file-inl.h"
	#include "dex/dex_file_loader.h"
	#include "dex/method_reference.h"
	#include "profile/profile_compilation_info.h"
	#include "runtime.h"

	namespace art {

	struct ImageSizes {
	size_t art_size = 0;
	size_t oat_size = 0;
	size_t vdex_size = 0;
	};

	std::ostream& operator<<(std::ostream& os, const ImageSizes& sizes) {
	os << "art=" << sizes.art_size << " oat=" << sizes.oat_size << " vdex=" << sizes.vdex_size;
	return os;
	}

	class Dex2oatImageTest : public CommonRuntimeTest {
	public:
	virtual void TearDown() OVERRIDE {}

	protected:
	// Visitors take method and type references
	template <typename MethodVisitor, typename ClassVisitor>
	void VisitLibcoreDexes(const MethodVisitor& method_visitor,
	const ClassVisitor& class_visitor,
	size_t method_frequency = 1,
	size_t class_frequency = 1) {
	size_t method_counter = 0;
	size_t class_counter = 0;
	for (const std::string& dex : GetLibCoreDexFileNames()) {
	std::vector<std::unique_ptr<const DexFile>> dex_files;
	std::string error_msg;
	const ArtDexFileLoader dex_file_loader;
	CHECK(dex_file_loader.Open(dex.c_str(),
	dex,
	/verify/ true,
	/verify_checksum/ false,
	&error_msg,
	&dex_files))
	<< error_msg;
	for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
	for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) {
	if (++method_counter % method_frequency == 0) {
	method_visitor(MethodReference(dex_file.get(), i));
	}
	}
	for (size_t i = 0; i < dex_file->NumTypeIds(); ++i) {
	if (++class_counter % class_frequency == 0) {
	class_visitor(TypeReference(dex_file.get(), dex::TypeIndex(i)));
	}
	}
	}
	}
	}

	static void WriteLine(File* file, std::string line) {
	line += '\n';
	EXPECT_TRUE(file->WriteFully(&line[0], line.length()));
	}

	void GenerateClasses(File* out_file, size_t frequency = 1) {
	VisitLibcoreDexes(VoidFunctor(),
	[out_file](TypeReference ref) {
	WriteLine(out_file, ref.dex_file->PrettyType(ref.TypeIndex()));
	}, frequency, frequency);
	EXPECT_EQ(out_file->Flush(), 0);
	}

	void GenerateMethods(File* out_file, size_t frequency = 1) {
	VisitLibcoreDexes([out_file](MethodReference ref) {
	WriteLine(out_file, ref.PrettyMethod());
	}, VoidFunctor(), frequency, frequency);
	EXPECT_EQ(out_file->Flush(), 0);
	}

	void AddRuntimeArg(std::vector<std::string>& args, const std::string& arg) {
	args.push_back("--runtime-arg");
	args.push_back(arg);
	}

	ImageSizes CompileImageAndGetSizes(const std::vector<std::string>& extra_args) {
	ImageSizes ret;
	ScratchFile scratch;
	std::string scratch_dir = scratch.GetFilename();
	while (!scratch_dir.empty() && scratch_dir.back() != '/') {
	scratch_dir.pop_back();
	}
	CHECK(!scratch_dir.empty()) << "No directory " << scratch.GetFilename();
	std::string error_msg;
	if (!CompileBootImage(extra_args, scratch.GetFilename(), &error_msg)) {
	LOG(ERROR) << "Failed to compile image " << scratch.GetFilename() << error_msg;
	}
	std::string art_file = scratch.GetFilename() + ".art";
	std::string oat_file = scratch.GetFilename() + ".oat";
	std::string vdex_file = scratch.GetFilename() + ".vdex";
	int64_t art_size = OS::GetFileSizeBytes(art_file.c_str());
	int64_t oat_size = OS::GetFileSizeBytes(oat_file.c_str());
	int64_t vdex_size = OS::GetFileSizeBytes(vdex_file.c_str());
	CHECK_GT(art_size, 0u) << art_file;
	CHECK_GT(oat_size, 0u) << oat_file;
	CHECK_GT(vdex_size, 0u) << vdex_file;
	ret.art_size = art_size;
	ret.oat_size = oat_size;
	ret.vdex_size = vdex_size;
	scratch.Close();
	// Clear image files since we compile the image multiple times and don't want to leave any
	// artifacts behind.
	ClearDirectory(scratch_dir.c_str(), /recursive/ false);
	return ret;
	}

	bool CompileBootImage(const std::vector<std::string>& extra_args,
	const std::string& image_file_name_prefix,
	std::string* error_msg) {
	Runtime* const runtime = Runtime::Current();
	std::vector<std::string> argv;
	argv.push_back(runtime->GetCompilerExecutable());
	AddRuntimeArg(argv, "-Xms64m");
	AddRuntimeArg(argv, "-Xmx64m");
	std::vector<std::string> dex_files = GetLibCoreDexFileNames();
	for (const std::string& dex_file : dex_files) {
	argv.push_back("--dex-file=" + dex_file);
	argv.push_back("--dex-location=" + dex_file);
	}
	if (runtime->IsJavaDebuggable()) {
	argv.push_back("--debuggable");
	}
	runtime->AddCurrentRuntimeFeaturesAsDex2OatArguments(&argv);

	AddRuntimeArg(argv, "-Xverify:softfail");

	if (!kIsTargetBuild) {
	argv.push_back("--host");
	}

	argv.push_back("--image=" + image_file_name_prefix + ".art");
	argv.push_back("--oat-file=" + image_file_name_prefix + ".oat");
	argv.push_back("--oat-location=" + image_file_name_prefix + ".oat");
	argv.push_back("--base=0x60000000");

	std::vector<std::string> compiler_options = runtime->GetCompilerOptions();
	argv.insert(argv.end(), compiler_options.begin(), compiler_options.end());

	// We must set --android-root.
	const char* android_root = getenv("ANDROID_ROOT");
	CHECK(android_root != nullptr);
	argv.push_back("--android-root=" + std::string(android_root));
	argv.insert(argv.end(), extra_args.begin(), extra_args.end());

	return RunDex2Oat(argv, error_msg);
	}

	int RunDex2Oat(const std::vector<std::string>& args, std::string* error_msg) {
	int link[2];

	if (pipe(link) == -1) {
	return false;
	}

	pid_t pid = fork();
	if (pid == -1) {
	return false;
	}

	if (pid == 0) {
	// We need dex2oat to actually log things.
	setenv("ANDROID_LOG_TAGS", "*:f", 1);
	dup2(link[1], STDERR_FILENO);
	close(link[0]);
	close(link[1]);
	std::vector<const char*> c_args;
	for (const std::string& str : args) {
	c_args.push_back(str.c_str());
	}
	c_args.push_back(nullptr);
	execv(c_args[0], const_cast<char* const*>(c_args.data()));
	exit(1);
	UNREACHABLE();
	} else {
	close(link[1]);
	char buffer[128];
	memset(buffer, 0, 128);
	ssize_t bytes_read = 0;

	while (TEMP_FAILURE_RETRY(bytes_read = read(link[0], buffer, 128)) > 0) {
	*error_msg += std::string(buffer, bytes_read);
	}
	close(link[0]);
	int status = -1;
	if (waitpid(pid, &status, 0) != -1) {
	return (status == 0);
	}
	return false;
	}
	}
	};

	TEST_F(Dex2oatImageTest, TestModesAndFilters) {
	if (kIsTargetBuild) {
	// This test is too slow for target builds.
	return;
	}
	ImageSizes base_sizes = CompileImageAndGetSizes({});
	ImageSizes image_classes_sizes;
	ImageSizes compiled_classes_sizes;
	ImageSizes compiled_methods_sizes;
	ImageSizes profile_sizes;
	std::cout << "Base compile sizes " << base_sizes << std::endl;
	// Test image classes
	{
	ScratchFile classes;
	GenerateClasses(classes.GetFile(), /frequency/ 1u);
	image_classes_sizes = CompileImageAndGetSizes(
	{"--image-classes=" + classes.GetFilename()});
	classes.Close();
	std::cout << "Image classes sizes " << image_classes_sizes << std::endl;
	// Putting all classes as image classes should increase art size
	EXPECT_GE(image_classes_sizes.art_size, base_sizes.art_size);
	// Sanity check that dex is the same size.
	EXPECT_EQ(image_classes_sizes.vdex_size, base_sizes.vdex_size);
	}
	// Test compiled classes.
	{
	ScratchFile classes;
	// Only compile every even class.
	GenerateClasses(classes.GetFile(), /frequency/ 2u);
	compiled_classes_sizes = CompileImageAndGetSizes(
	{"--image-classes=" + classes.GetFilename()});
	classes.Close();
	std::cout << "Compiled classes sizes " << compiled_classes_sizes << std::endl;
	// Art file should be smaller than image classes version since we included fewer classes in the
	// list.
	EXPECT_LT(compiled_classes_sizes.art_size, image_classes_sizes.art_size);
	}
	static size_t kMethodFrequency = 3;
	static size_t kTypeFrequency = 4;
	// Test compiling fewer methods and classes.
	{
	ScratchFile classes;
	// Only compile every even class.
	GenerateClasses(classes.GetFile(), kTypeFrequency);
	compiled_methods_sizes = CompileImageAndGetSizes(
	{"--image-classes=" + classes.GetFilename()});
	classes.Close();
	std::cout << "Compiled fewer methods sizes " << compiled_methods_sizes << std::endl;
	}
	// Cross verify profile based image against image-classes and compiled-methods to make sure it
	// matches.
	{
	ProfileCompilationInfo profile;
	VisitLibcoreDexes([&profile](MethodReference ref) {
	uint32_t flags = ProfileCompilationInfo::MethodHotness::kFlagHot \|
	ProfileCompilationInfo::MethodHotness::kFlagStartup;
	EXPECT_TRUE(profile.AddMethodIndex(
	static_cast<ProfileCompilationInfo::MethodHotness::Flag>(flags),
	ref));
	}, [&profile](TypeReference ref) {
	EXPECT_TRUE(profile.AddClassForDex(ref));
	}, kMethodFrequency, kTypeFrequency);
	ScratchFile profile_file;
	profile.Save(profile_file.GetFile()->Fd());
	EXPECT_EQ(profile_file.GetFile()->Flush(), 0);
	profile_sizes = CompileImageAndGetSizes(
	{"--profile-file=" + profile_file.GetFilename(),
	"--compiler-filter=speed-profile"});
	profile_file.Close();
	std::cout << "Profile sizes " << profile_sizes << std::endl;
	// Since there is some difference between profile vs image + methods due to layout, check that
	// the range is within expected margins (+-10%).
	const double kRatio = 0.90;
	EXPECT_LE(profile_sizes.art_size * kRatio, compiled_methods_sizes.art_size);
	// TODO(mathieuc): Find a reliable way to check compiled code. b/63746626
	// EXPECT_LE(profile_sizes.oat_size * kRatio, compiled_methods_sizes.oat_size);
	EXPECT_LE(profile_sizes.vdex_size * kRatio, compiled_methods_sizes.vdex_size);
	EXPECT_GE(profile_sizes.art_size / kRatio, compiled_methods_sizes.art_size);
	// TODO(mathieuc): Find a reliable way to check compiled code. b/63746626
	// EXPECT_GE(profile_sizes.oat_size / kRatio, compiled_methods_sizes.oat_size);
	EXPECT_GE(profile_sizes.vdex_size / kRatio, compiled_methods_sizes.vdex_size);
	}
	// Test dirty image objects.
	{
	ScratchFile classes;
	GenerateClasses(classes.GetFile(), /frequency/ 1u);
	image_classes_sizes = CompileImageAndGetSizes(
	{"--dirty-image-objects=" + classes.GetFilename()});
	classes.Close();
	std::cout << "Dirty image object sizes " << image_classes_sizes << std::endl;
	}
	}

	} // namespace art