Home | History | Annotate | Download | only in simpleperf 
      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 
     22 #include <string>
     23 #include <vector>
     24 
     25 #include <android-base/logging.h>
     26 #include <android-base/macros.h>
     27 #include <ziparchive/zip_archive.h>
     28 
     29 #define ALIGN(value, alignment) (((value) + (alignment)-1) & ~((alignment)-1))
     30 
     31 #ifdef _WIN32
     32 #define CLOSE_ON_EXEC_MODE ""
     33 #else
     34 #define CLOSE_ON_EXEC_MODE "e"
     35 #endif
     36 
     37 // OneTimeAllocator is used to allocate memory many times and free only once at the end.
     38 // It reduces the cost to free each allocated memory.
     39 class OneTimeFreeAllocator {
     40  public:
     41   OneTimeFreeAllocator(size_t unit_size = 8192u)
     42       : unit_size_(unit_size), cur_(nullptr), end_(nullptr) {
     43   }
     44 
     45   ~OneTimeFreeAllocator() {
     46     Clear();
     47   }
     48 
     49   void Clear();
     50   const char* AllocateString(const std::string& s);
     51 
     52  private:
     53   const size_t unit_size_;
     54   std::vector<char*> v_;
     55   char* cur_;
     56   char* end_;
     57 };
     58 
     59 class FileHelper {
     60  public:
     61   static FileHelper OpenReadOnly(const std::string& filename);
     62   static FileHelper OpenWriteOnly(const std::string& filename);
     63 
     64   FileHelper(FileHelper&& other) {
     65     fd_ = other.fd_;
     66     other.fd_ = -1;
     67   }
     68 
     69   ~FileHelper();
     70 
     71   explicit operator bool() const {
     72     return fd_ != -1;
     73   }
     74 
     75   int fd() const {
     76     return fd_;
     77   }
     78 
     79  private:
     80   FileHelper(int fd) : fd_(fd) {}
     81   int fd_;
     82 
     83   DISALLOW_COPY_AND_ASSIGN(FileHelper);
     84 };
     85 
     86 class ArchiveHelper {
     87  public:
     88   ArchiveHelper(int fd, const std::string& debug_filename);
     89   ~ArchiveHelper();
     90 
     91   explicit operator bool() const {
     92     return valid_;
     93   }
     94   ZipArchiveHandle &archive_handle() {
     95     return handle_;
     96   }
     97 
     98  private:
     99   ZipArchiveHandle handle_;
    100   bool valid_;
    101 
    102   DISALLOW_COPY_AND_ASSIGN(ArchiveHelper);
    103 };
    104 
    105 template <class T>
    106 void MoveFromBinaryFormat(T& data, const char*& p) {
    107   data = *reinterpret_cast<const T*>(p);
    108   p += sizeof(T);
    109 }
    110 
    111 void PrintIndented(size_t indent, const char* fmt, ...);
    112 
    113 bool IsPowerOfTwo(uint64_t value);
    114 
    115 void GetEntriesInDir(const std::string& dirpath, std::vector<std::string>* files,
    116                      std::vector<std::string>* subdirs);
    117 bool IsDir(const std::string& dirpath);
    118 bool IsRegularFile(const std::string& filename);
    119 uint64_t GetFileSize(const std::string& filename);
    120 bool MkdirWithParents(const std::string& path);
    121 
    122 bool GetLogSeverity(const std::string& name, android::base::LogSeverity* severity);
    123 
    124 bool IsRoot();
    125 #endif  // SIMPLE_PERF_UTILS_H_
    126