blob: 377b7fe352c71a3fb306e9e298e1ecd7020c48a2 [file] [log] [blame]
/*
* Copyright (C) 2016 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.
*/
#ifndef ART_COMPILER_UTILS_ATOMIC_DEX_REF_MAP_INL_H_
#define ART_COMPILER_UTILS_ATOMIC_DEX_REF_MAP_INL_H_
#include "atomic_dex_ref_map.h"
#include <type_traits>
#include "dex/class_reference.h"
#include "dex/dex_file-inl.h"
#include "dex/method_reference.h"
#include "dex/type_reference.h"
namespace art {
template <typename DexFileReferenceType, typename Value>
inline size_t AtomicDexRefMap<DexFileReferenceType, Value>::NumberOfDexIndices(
const DexFile* dex_file) {
// TODO: Use specialization for this? Not sure if worth it.
static_assert(std::is_same<DexFileReferenceType, MethodReference>::value ||
std::is_same<DexFileReferenceType, ClassReference>::value ||
std::is_same<DexFileReferenceType, TypeReference>::value,
"invalid index type");
if (std::is_same<DexFileReferenceType, MethodReference>::value) {
return dex_file->NumMethodIds();
}
if (std::is_same<DexFileReferenceType, ClassReference>::value) {
return dex_file->NumClassDefs();
}
if (std::is_same<DexFileReferenceType, TypeReference>::value) {
return dex_file->NumTypeIds();
}
UNREACHABLE();
}
template <typename DexFileReferenceType, typename Value>
inline typename AtomicDexRefMap<DexFileReferenceType, Value>::InsertResult
AtomicDexRefMap<DexFileReferenceType, Value>::Insert(const DexFileReferenceType& ref,
const Value& expected,
const Value& desired) {
ElementArray* const array = GetArray(ref.dex_file);
if (array == nullptr) {
return kInsertResultInvalidDexFile;
}
DCHECK_LT(ref.index, array->size());
return (*array)[ref.index].CompareAndSetStrongSequentiallyConsistent(expected, desired)
? kInsertResultSuccess
: kInsertResultCASFailure;
}
template <typename DexFileReferenceType, typename Value>
inline bool AtomicDexRefMap<DexFileReferenceType, Value>::Get(const DexFileReferenceType& ref,
Value* out) const {
const ElementArray* const array = GetArray(ref.dex_file);
if (array == nullptr) {
return false;
}
*out = (*array)[ref.index].load(std::memory_order_relaxed);
return true;
}
template <typename DexFileReferenceType, typename Value>
inline bool AtomicDexRefMap<DexFileReferenceType, Value>::Remove(const DexFileReferenceType& ref,
Value* out) {
ElementArray* const array = GetArray(ref.dex_file);
if (array == nullptr) {
return false;
}
*out = (*array)[ref.index].exchange(nullptr, std::memory_order_seq_cst);
return true;
}
template <typename DexFileReferenceType, typename Value>
inline void AtomicDexRefMap<DexFileReferenceType, Value>::AddDexFile(const DexFile* dex_file) {
arrays_.Put(dex_file, std::move(ElementArray(NumberOfDexIndices(dex_file))));
}
template <typename DexFileReferenceType, typename Value>
inline void AtomicDexRefMap<DexFileReferenceType, Value>::AddDexFiles(
const std::vector<const DexFile*>& dex_files) {
for (const DexFile* dex_file : dex_files) {
if (!HaveDexFile(dex_file)) {
AddDexFile(dex_file);
}
}
}
template <typename DexFileReferenceType, typename Value>
inline typename AtomicDexRefMap<DexFileReferenceType, Value>::ElementArray*
AtomicDexRefMap<DexFileReferenceType, Value>::GetArray(const DexFile* dex_file) {
auto it = arrays_.find(dex_file);
return (it != arrays_.end()) ? &it->second : nullptr;
}
template <typename DexFileReferenceType, typename Value>
inline const typename AtomicDexRefMap<DexFileReferenceType, Value>::ElementArray*
AtomicDexRefMap<DexFileReferenceType, Value>::GetArray(const DexFile* dex_file) const {
auto it = arrays_.find(dex_file);
return (it != arrays_.end()) ? &it->second : nullptr;
}
template <typename DexFileReferenceType, typename Value> template <typename Visitor>
inline void AtomicDexRefMap<DexFileReferenceType, Value>::Visit(const Visitor& visitor) {
for (auto& pair : arrays_) {
const DexFile* dex_file = pair.first;
const ElementArray& elements = pair.second;
for (size_t i = 0; i < elements.size(); ++i) {
visitor(DexFileReference(dex_file, i), elements[i].load(std::memory_order_relaxed));
}
}
}
template <typename DexFileReferenceType, typename Value>
inline void AtomicDexRefMap<DexFileReferenceType, Value>::ClearEntries() {
for (auto& it : arrays_) {
for (auto& element : it.second) {
element.store(nullptr, std::memory_order_relaxed);
}
}
}
template <typename DexFileReferenceType, typename Value>
inline std::vector<const DexFile*> AtomicDexRefMap<DexFileReferenceType, Value>::GetDexFiles()
const {
std::vector<const DexFile*> result;
result.reserve(arrays_.size());
for (auto& it : arrays_) {
result.push_back(it.first);
}
return result;
}
} // namespace art
#endif // ART_COMPILER_UTILS_ATOMIC_DEX_REF_MAP_INL_H_