folly::symbolizer::SignalSafeElfCache Class Reference

#include <ElfCache.h>

Inheritance diagram for folly::symbolizer::SignalSafeElfCache:

Classes
class	Path

Public Member Functions
	SignalSafeElfCache (size_t capacity)
std::shared_ptr< ElfFile >	getFile (StringPiece path) override
Public Member Functions inherited from folly::symbolizer::ElfCacheBase
virtual	~ElfCacheBase ()

Private Attributes
Path	scratchpad_
boost::container::flat_map< Path, int >	map_
std::vector< std::shared_ptr< ElfFile > >	slots_

Detailed Description

Cache ELF files. Async-signal-safe: does memory allocation upfront.

Will not grow; once the capacity is reached, lookups for files that aren't already in the cache will fail (return nullptr).

Not MT-safe. May not be used concurrently from multiple threads.

NOTE that async-signal-safety is preserved only as long as the SignalSafeElfCache object exists; after the SignalSafeElfCache object is destroyed, destroying returned shared_ptr<ElfFile> objects may cause ElfFile objects to be destroyed, and that's not async-signal-safe.

Definition at line 63 of file ElfCache.h.

Constructor & Destructor Documentation

folly::symbolizer::SignalSafeElfCache::SignalSafeElfCache ( size_t  capacity )

explicit

Definition at line 53 of file ElfCache.cpp.

References i, map_, and slots_.

                                                      {
  map_.reserve(capacity);
  slots_.reserve(capacity);

  // Preallocate
  for (size_t i = 0; i < capacity; ++i) {
    slots_.push_back(std::make_shared<ElfFile>());
  }
}

Member Function Documentation

std::shared_ptr< ElfFile > folly::symbolizer::SignalSafeElfCache::getFile ( StringPiece  path )

overridevirtual

Implements folly::symbolizer::ElfCacheBase.

Definition at line 63 of file ElfCache.cpp.

References folly::symbolizer::SignalSafeElfCache::Path::assign(), folly::symbolizer::SignalSafeElfCache::Path::data(), f, folly::symbolizer::SignalSafeElfCache::Path::kMaxSize, folly::symbolizer::ElfFile::kSuccess, map_, scratchpad_, folly::Range< Iter >::size(), and slots_.

                                                                {
  if (p.size() > Path::kMaxSize) {
    return nullptr;
  }

  scratchpad_.assign(p);
  auto pos = map_.find(scratchpad_);
  if (pos != map_.end()) {
    return slots_[pos->second];
  }

  size_t n = map_.size();
  if (n >= slots_.size()) {
    DCHECK_EQ(map_.size(), slots_.size());
    return nullptr;
  }

  auto& f = slots_[n];

  const char* msg = "";
  int r = f->openAndFollow(scratchpad_.data(), true, &msg);
  if (r != ElfFile::kSuccess) {
    return nullptr;
  }

  map_[scratchpad_] = n;
  return f;
}

Member Data Documentation

boost::container::flat_map<Path, int> folly::symbolizer::SignalSafeElfCache::map_

private

Definition at line 109 of file ElfCache.h.

Referenced by getFile(), and SignalSafeElfCache().

Path folly::symbolizer::SignalSafeElfCache::scratchpad_

private

Definition at line 108 of file ElfCache.h.

Referenced by getFile().

std::vector<std::shared_ptr<ElfFile> > folly::symbolizer::SignalSafeElfCache::slots_

private

Definition at line 110 of file ElfCache.h.

Referenced by getFile(), and SignalSafeElfCache().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/experimental/symbolizer/ElfCache.h
• proxygen/folly/folly/experimental/symbolizer/ElfCache.cpp