1/* 2 * Copyright (C) 2015 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#ifndef SIMPLE_PERF_UTILS_H_ 18#define SIMPLE_PERF_UTILS_H_ 19 20#include <stddef.h> 21#include <time.h> 22 23#include <string> 24#include <vector> 25 26#include <android-base/logging.h> 27#include <android-base/macros.h> 28#include <ziparchive/zip_archive.h> 29 30static inline uint64_t Align(uint64_t value, uint64_t alignment) { 31 return (value + alignment - 1) & ~(alignment - 1); 32} 33 34#ifdef _WIN32 35#define CLOSE_ON_EXEC_MODE "" 36#else 37#define CLOSE_ON_EXEC_MODE "e" 38#endif 39 40// OneTimeAllocator is used to allocate memory many times and free only once at the end. 41// It reduces the cost to free each allocated memory. 42class OneTimeFreeAllocator { 43 public: 44 explicit OneTimeFreeAllocator(size_t unit_size = 8192u) 45 : unit_size_(unit_size), cur_(nullptr), end_(nullptr) { 46 } 47 48 ~OneTimeFreeAllocator() { 49 Clear(); 50 } 51 52 void Clear(); 53 const char* AllocateString(const std::string& s); 54 55 private: 56 const size_t unit_size_; 57 std::vector<char*> v_; 58 char* cur_; 59 char* end_; 60}; 61 62class FileHelper { 63 public: 64 static FileHelper OpenReadOnly(const std::string& filename); 65 static FileHelper OpenWriteOnly(const std::string& filename); 66 67 FileHelper(FileHelper&& other) { 68 fd_ = other.fd_; 69 other.fd_ = -1; 70 } 71 72 ~FileHelper(); 73 74 explicit operator bool() const { 75 return fd_ != -1; 76 } 77 78 int fd() const { 79 return fd_; 80 } 81 82 private: 83 explicit FileHelper(int fd) : fd_(fd) {} 84 int fd_; 85 86 DISALLOW_COPY_AND_ASSIGN(FileHelper); 87}; 88 89class ArchiveHelper { 90 public: 91 ArchiveHelper(int fd, const std::string& debug_filename); 92 ~ArchiveHelper(); 93 94 explicit operator bool() const { 95 return valid_; 96 } 97 ZipArchiveHandle &archive_handle() { 98 return handle_; 99 } 100 101 private: 102 ZipArchiveHandle handle_; 103 bool valid_; 104 105 DISALLOW_COPY_AND_ASSIGN(ArchiveHelper); 106}; 107 108template <class T> 109void MoveFromBinaryFormat(T& data, const char*& p) { 110 static_assert(std::is_standard_layout<T>::value, "not standard layout"); 111 memcpy(&data, p, sizeof(T)); 112 p += sizeof(T); 113} 114 115template <class T> 116void MoveFromBinaryFormat(T* data_p, size_t n, const char*& p) { 117 static_assert(std::is_standard_layout<T>::value, "not standard layout"); 118 size_t size = n * sizeof(T); 119 memcpy(data_p, p, size); 120 p += size; 121} 122 123template <class T> 124void MoveToBinaryFormat(const T& data, char*& p) { 125 static_assert(std::is_standard_layout<T>::value, "not standard layout"); 126 memcpy(p, &data, sizeof(T)); 127 p += sizeof(T); 128} 129 130template <class T> 131void MoveToBinaryFormat(const T* data_p, size_t n, char*& p) { 132 static_assert(std::is_standard_layout<T>::value, "not standard layout"); 133 size_t size = n * sizeof(T); 134 memcpy(p, data_p, size); 135 p += size; 136} 137 138void PrintIndented(size_t indent, const char* fmt, ...); 139void FprintIndented(FILE* fp, size_t indent, const char* fmt, ...); 140 141bool IsPowerOfTwo(uint64_t value); 142 143std::vector<std::string> GetEntriesInDir(const std::string& dirpath); 144std::vector<std::string> GetSubDirs(const std::string& dirpath); 145bool IsDir(const std::string& dirpath); 146bool IsRegularFile(const std::string& filename); 147uint64_t GetFileSize(const std::string& filename); 148bool MkdirWithParents(const std::string& path); 149 150bool XzDecompress(const std::string& compressed_data, std::string* decompressed_data); 151 152bool GetLogSeverity(const std::string& name, android::base::LogSeverity* severity); 153 154bool IsRoot(); 155 156struct KernelSymbol { 157 uint64_t addr; 158 char type; 159 const char* name; 160 const char* module; // If nullptr, the symbol is not in a kernel module. 161}; 162 163bool ProcessKernelSymbols(std::string& symbol_data, 164 const std::function<bool(const KernelSymbol&)>& callback); 165 166size_t GetPageSize(); 167 168uint64_t ConvertBytesToValue(const char* bytes, uint32_t size); 169 170timeval SecondToTimeval(double time_in_sec); 171 172#endif // SIMPLE_PERF_UTILS_H_ 173