memory_replay/Pointers.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 <err.h>
  18 #include <inttypes.h>
  19 #include <stdatomic.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <sys/mman.h>
  24 #include <unistd.h>
  25
  26 #include "err.h"
  27 #include "Pointers.h"
  28
  29 Pointers::Pointers(size_t max_allocs) {
  30   size_t pagesize = getpagesize();
  31   // Create a mmap that contains a 4:1 ratio of allocations to entries.
  32   // Align to a page.
  33   pointers_size_ = (max_allocs * 4 * sizeof(pointer_data) + pagesize - 1) & ~(pagesize - 1);
  34   max_pointers_ = pointers_size_ / sizeof(pointer_data);
  35   void* memory = mmap(nullptr, pointers_size_, PROT_READ | PROT_WRITE,
  36                       MAP_ANON | MAP_PRIVATE, -1, 0);
  37   if (memory == MAP_FAILED) {
  38     err(1, "Unable to allocate data for pointer hash: %zu total_allocs\n", max_allocs);
  39   }
  40   // Make sure that all of the PSS for this is counted right away.
  41   memset(memory, 0, pointers_size_);
  42   pointers_ = reinterpret_cast<pointer_data*>(memory);
  43 }
  44
  45 Pointers::~Pointers() {
  46   if (pointers_ != nullptr) {
  47     munmap(pointers_, pointers_size_);
  48     pointers_ = nullptr;
  49   }
  50 }
  51
  52 void Pointers::Add(uintptr_t key_pointer, void* pointer) {
  53   pointer_data* data = FindEmpty(key_pointer);
  54   if (data == nullptr) {
  55     err(1, "No empty entry found for 0x%" PRIxPTR "\n", key_pointer);
  56   }
  57   atomic_store(&data->key_pointer, key_pointer);
  58   data->pointer = pointer;
  59 }
  60
  61 void* Pointers::Remove(uintptr_t key_pointer) {
  62   if (key_pointer == 0) {
  63     err(1, "Illegal zero value passed to Remove\n");
  64   }
  65
  66   pointer_data* data = Find(key_pointer);
  67   if (data == nullptr) {
  68     err(1, "No pointer value found for 0x%" PRIxPTR "\n", key_pointer);
  69   }
  70
  71   void* pointer = data->pointer;
  72   atomic_store(&data->key_pointer, uintptr_t(0));
  73
  74   return pointer;
  75 }
  76
  77 pointer_data* Pointers::Find(uintptr_t key_pointer) {
  78   size_t index = GetHash(key_pointer);
  79   for (size_t entries = max_pointers_; entries != 0; entries--) {
  80     if (atomic_load(&pointers_[index].key_pointer) == key_pointer) {
  81       return pointers_ + index;
  82     }
  83     if (++index == max_pointers_) {
  84       index = 0;
  85     }
  86   }
  87   return nullptr;
  88 }
  89
  90 pointer_data* Pointers::FindEmpty(uintptr_t key_pointer) {
  91   size_t index = GetHash(key_pointer);
  92   for (size_t entries = 0; entries < max_pointers_; entries++) {
  93     uintptr_t empty = 0;
  94     if (atomic_compare_exchange_strong(&pointers_[index].key_pointer, &empty,
  95         uintptr_t(1))) {
  96       return pointers_ + index;
  97     }
  98     if (++index == max_pointers_) {
  99       index = 0;
 100     }
 101   }
 102   return nullptr;
 103 }
 104
 105 size_t Pointers::GetHash(uintptr_t key_pointer) {
 106   return key_pointer % max_pointers_;
 107 }
 108
 109 void Pointers::FreeAll() {
 110   for (size_t i = 0; i < max_pointers_; i++) {
 111     if (atomic_load(&pointers_[i].key_pointer) != 0) {
 112       free(pointers_[i].pointer);
 113     }
 114   }
 115 }