memory_replay/Action.cpp

   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 #include <inttypes.h>
  18 #include <malloc.h>
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/param.h>
  24 #include <time.h>
  25
  26 #include <new>
  27
  28 #include "Action.h"
  29 #include "Threads.h"
  30 #include "Pointers.h"
  31
  32 static uint64_t nanotime() {
  33   struct timespec t;
  34   t.tv_sec = t.tv_nsec = 0;
  35   clock_gettime(CLOCK_MONOTONIC, &t);
  36   return static_cast<uint64_t>(t.tv_sec) * 1000000000LL + t.tv_nsec;
  37 }
  38
  39 class EndThreadAction : public Action {
  40  public:
  41   EndThreadAction() {}
  42
  43   bool EndThread() override { return true; }
  44
  45   uint64_t Execute(Pointers*) override { return 0; }
  46 };
  47
  48 class AllocAction : public Action {
  49  public:
  50   AllocAction(uintptr_t key_pointer) : key_pointer_(key_pointer) {}
  51
  52  protected:
  53   uintptr_t key_pointer_ = 0;
  54   size_t size_ = 0;
  55 };
  56
  57 class MallocAction : public AllocAction {
  58  public:
  59   MallocAction(uintptr_t key_pointer, const char* line) : AllocAction(key_pointer) {
  60     if (sscanf(line, "%zu", &size_) != 1) {
  61       is_error_ = true;
  62     }
  63   }
  64
  65   uint64_t Execute(Pointers* pointers) override {
  66     uint64_t time_nsecs = nanotime();
  67     void* memory = malloc(size_);
  68     time_nsecs = nanotime() - time_nsecs;
  69
  70     memset(memory, 1, size_);
  71     pointers->Add(key_pointer_, memory);
  72
  73     return time_nsecs;
  74   }
  75 };
  76
  77 class CallocAction : public AllocAction {
  78  public:
  79   CallocAction(uintptr_t key_pointer, const char* line) : AllocAction(key_pointer) {
  80     if (sscanf(line, "%zu %zu", &n_elements_, &size_) != 2) {
  81       is_error_ = true;
  82     }
  83   }
  84
  85   uint64_t Execute(Pointers* pointers) override {
  86     uint64_t time_nsecs = nanotime();
  87     void* memory = calloc(n_elements_, size_);
  88     time_nsecs = nanotime() - time_nsecs;
  89
  90     memset(memory, 0, n_elements_ * size_);
  91     pointers->Add(key_pointer_, memory);
  92
  93     return time_nsecs;
  94   }
  95
  96  private:
  97   size_t n_elements_ = 0;
  98 };
  99
 100 class ReallocAction : public AllocAction {
 101  public:
 102   ReallocAction(uintptr_t key_pointer, const char* line) : AllocAction(key_pointer) {
 103     if (sscanf(line, "%" SCNxPTR " %zu", &old_pointer_, &size_) != 2) {
 104       is_error_ = true;
 105     }
 106   }
 107
 108   bool DoesFree() override { return old_pointer_ != 0; }
 109
 110   uint64_t Execute(Pointers* pointers) override {
 111     void* old_memory = nullptr;
 112     if (old_pointer_ != 0) {
 113       old_memory = pointers->Remove(old_pointer_);
 114     }
 115
 116     uint64_t time_nsecs = nanotime();
 117     void* memory = realloc(old_memory, size_);
 118     time_nsecs = nanotime() - time_nsecs;
 119
 120     memset(memory, 1, size_);
 121     pointers->Add(key_pointer_, memory);
 122
 123     return time_nsecs;
 124   }
 125
 126  private:
 127   uintptr_t old_pointer_ = 0;
 128 };
 129
 130 class MemalignAction : public AllocAction {
 131  public:
 132   MemalignAction(uintptr_t key_pointer, const char* line) : AllocAction(key_pointer) {
 133     if (sscanf(line, "%zu %zu", &align_, &size_) != 2) {
 134       is_error_ = true;
 135     }
 136   }
 137
 138   uint64_t Execute(Pointers* pointers) override {
 139     uint64_t time_nsecs = nanotime();
 140     void* memory = memalign(align_, size_);
 141     time_nsecs = nanotime() - time_nsecs;
 142
 143     memset(memory, 1, size_);
 144     pointers->Add(key_pointer_, memory);
 145
 146     return time_nsecs;
 147   }
 148
 149  private:
 150   size_t align_ = 0;
 151 };
 152
 153 class FreeAction : public AllocAction {
 154  public:
 155   FreeAction(uintptr_t key_pointer) : AllocAction(key_pointer) {
 156   }
 157
 158   bool DoesFree() override { return key_pointer_ != 0; }
 159
 160   uint64_t Execute(Pointers* pointers) override {
 161     if (key_pointer_) {
 162       void* memory = pointers->Remove(key_pointer_);
 163       uint64_t time_nsecs = nanotime();
 164       free(memory);
 165       return nanotime() - time_nsecs;
 166     }
 167     return 0;
 168   }
 169 };
 170
 171 size_t Action::MaxActionSize() {
 172   size_t max = MAX(sizeof(EndThreadAction), sizeof(MallocAction));
 173   max = MAX(max, sizeof(CallocAction));
 174   max = MAX(max, sizeof(ReallocAction));
 175   max = MAX(max, sizeof(MemalignAction));
 176   return MAX(max, sizeof(FreeAction));
 177 }
 178
 179 Action* Action::CreateAction(uintptr_t key_pointer, const char* type,
 180                              const char* line, void* action_memory) {
 181   Action* action = nullptr;
 182   if (strcmp(type, "malloc") == 0) {
 183     action = new (action_memory) MallocAction(key_pointer, line);
 184   } else if (strcmp(type, "free") == 0) {
 185     action = new (action_memory) FreeAction(key_pointer);
 186   } else if (strcmp(type, "calloc") == 0) {
 187     action = new (action_memory) CallocAction(key_pointer, line);
 188   } else if (strcmp(type, "realloc") == 0) {
 189     action = new (action_memory) ReallocAction(key_pointer, line);
 190   } else if (strcmp(type, "memalign") == 0) {
 191     action = new (action_memory) MemalignAction(key_pointer, line);
 192   } else if (strcmp(type, "thread_done") == 0) {
 193     action = new (action_memory) EndThreadAction();
 194   }
 195
 196   if (action == nullptr || action->IsError()) {
 197     return nullptr;
 198   }
 199   return action;
 200 }