sysio::chain::eosvmoc::code_cache_base Class Reference

#include <code_cache.hpp>

Inheritance diagram for sysio::chain::eosvmoc::code_cache_base:

Collaboration diagram for sysio::chain::eosvmoc::code_cache_base:

Public Member Functions
	code_cache_base (const bfs::path data_dir, const eosvmoc::config &eosvmoc_config, const chainbase::database &db)
	~code_cache_base ()
const int &	fd () const
void	free_code (const digest_type &code_id, const uint8_t &vm_version)

Protected Types
typedef boost::multi_index_container< code_descriptor, indexed_by< sequenced<>, hashed_unique< tag< by_hash >, composite_key< code_descriptor, member< code_descriptor, digest_type, &code_descriptor::code_hash >, member< code_descriptor, uint8_t, &code_descriptor::vm_version > > > > >	code_cache_index

Protected Member Functions
void	check_eviction_threshold (size_t free_bytes)
void	run_eviction_round ()
void	set_on_disk_region_dirty (bool)
template<typename T >
void	serialize_cache_index (fc::datastream< T > &ds)

Protected Attributes
code_cache_index	_cache_index
const chainbase::database &	_db
bfs::path	_cache_file_path
int	_cache_fd
io_context	_ctx
local::datagram_protocol::socket	_compile_monitor_write_socket {_ctx}
local::datagram_protocol::socket	_compile_monitor_read_socket {_ctx}
std::unordered_set< code_tuple >	_queued_compiles
std::unordered_map< code_tuple, bool >	_outstanding_compiles_and_poison
size_t	_free_bytes_eviction_threshold

Detailed Description

Definition at line 39 of file code_cache.hpp.

Member Typedef Documentation

code_cache_index

boost::multi_index_container< code_descriptor, indexed_by< sequenced<>, hashed_unique<tag<by_hash>, composite_key< code_descriptor, member<code_descriptor, digest_type, &code_descriptor::code_hash>, member<code_descriptor, uint8_t, &code_descriptor::vm_version> > > > > sysio::chain::eosvmoc::code_cache_base::code_cache_index

protected

Definition at line 62 of file code_cache.hpp.

Constructor & Destructor Documentation

code_cache_base()

sysio::chain::eosvmoc::code_cache_base::code_cache_base	(	const bfs::path	data_dir,
		const eosvmoc::config &	eosvmoc_config,
		const chainbase::database &	db )

Definition at line 205 of file code_cache.cpp.

                                                                                                                                     :
   _db(db),
   _cache_file_path(data_dir/"code_cache.bin")
{
   static_assert(sizeof(allocator_t) <= header_offset, "header offset intersects with allocator");
 
   bfs::create_directories(data_dir);
 
   if(!bfs::exists(_cache_file_path)) {
      SYS_ASSERT(eosvmoc_config.cache_size >= allocator_t::get_min_size(total_header_size), database_exception, "configured code cache size is too small");
      std::ofstream ofs(_cache_file_path.generic_string(), std::ofstream::trunc);
      SYS_ASSERT(ofs.good(), database_exception, "unable to create SYS VM Optimized Compiler code cache");
      bfs::resize_file(_cache_file_path, eosvmoc_config.cache_size);
      bip::file_mapping creation_mapping(_cache_file_path.generic_string().c_str(), bip::read_write);
      bip::mapped_region creation_region(creation_mapping, bip::read_write);
      new (creation_region.get_address()) allocator_t(eosvmoc_config.cache_size, total_header_size);
      new ((char*)creation_region.get_address() + header_offset) code_cache_header;
   }
 
   code_cache_header cache_header;
   {
      char header_buff[total_header_size];
      std::ifstream hs(_cache_file_path.generic_string(), std::ifstream::binary);
      hs.read(header_buff, sizeof(header_buff));
      SYS_ASSERT(!hs.fail(), bad_database_version_exception, "failed to read code cache header");
      memcpy((char*)&cache_header, header_buff + header_offset, sizeof(cache_header));
   }
 
   SYS_ASSERT(cache_header.id == header_id, bad_database_version_exception, "existing SYS VM OC code cache not compatible with this version");
   SYS_ASSERT(!cache_header.dirty, database_exception, "code cache is dirty");
 
   set_on_disk_region_dirty(true);
 
   auto existing_file_size = bfs::file_size(_cache_file_path);
   if(eosvmoc_config.cache_size > existing_file_size) {
      bfs::resize_file(_cache_file_path, eosvmoc_config.cache_size);
 
      bip::file_mapping resize_mapping(_cache_file_path.generic_string().c_str(), bip::read_write);
      bip::mapped_region resize_region(resize_mapping, bip::read_write);
 
      allocator_t* resize_allocator = reinterpret_cast<allocator_t*>(resize_region.get_address());
      resize_allocator->grow(eosvmoc_config.cache_size - existing_file_size);
   }
 
   _cache_fd = ::open(_cache_file_path.generic_string().c_str(), O_RDWR | O_CLOEXEC);
   SYS_ASSERT(_cache_fd >= 0, database_exception, "failure to open code cache");
 
   //load up the previous cache index
   char* code_mapping = (char*)mmap(nullptr, eosvmoc_config.cache_size, PROT_READ|PROT_WRITE, MAP_SHARED, _cache_fd, 0);
   SYS_ASSERT(code_mapping != MAP_FAILED, database_exception, "failure to mmap code cache");
 
   allocator_t* allocator = reinterpret_cast<allocator_t*>(code_mapping);
 
   if(cache_header.serialized_descriptor_index) {
      fc::datastream<const char*> ds(code_mapping + cache_header.serialized_descriptor_index, eosvmoc_config.cache_size - cache_header.serialized_descriptor_index);
      unsigned number_entries;
      fc::raw::unpack(ds, number_entries);
      for(unsigned i = 0; i < number_entries; ++i) {
         code_descriptor cd;
         fc::raw::unpack(ds, cd);
         if(cd.codegen_version != current_codegen_version) {
            allocator->deallocate(code_mapping + cd.code_begin);
            allocator->deallocate(code_mapping + cd.initdata_begin);
            continue;
         }
         _cache_index.push_back(std::move(cd));
      }
      allocator->deallocate(code_mapping + cache_header.serialized_descriptor_index);
 
      ilog("SYS VM Optimized Compiler code cache loaded with ${c} entries; ${f} of ${t} bytes free", ("c", number_entries)("f", allocator->get_free_memory())("t", allocator->get_size()));
   }
   munmap(code_mapping, eosvmoc_config.cache_size);
 
   _free_bytes_eviction_threshold = eosvmoc_config.cache_size * .1;
 
   wrapped_fd compile_monitor_conn = get_connection_to_compile_monitor(_cache_fd);
 
   //okay, let's do this by the book: we're not allowed to write & read on different threads to the same asio socket. So create two fds
   //representing the same unix socket. we'll read on one and write on the other
   int duped = dup(compile_monitor_conn);
   _compile_monitor_write_socket.assign(local::datagram_protocol(), duped);
   _compile_monitor_read_socket.assign(local::datagram_protocol(), compile_monitor_conn.release());
}

Here is the call graph for this function:

~code_cache_base()

sysio::chain::eosvmoc::code_cache_base::~code_cache_base

(

)

Definition at line 306 of file code_cache.cpp.

                                  {
   //reopen the code cache in our process
   struct stat st;
   if(fstat(_cache_fd, &st))
      return;
   char* code_mapping = (char*)mmap(nullptr, st.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, _cache_fd, 0);
   if(code_mapping == MAP_FAILED)
      return;
 
   allocator_t* allocator = reinterpret_cast<allocator_t*>(code_mapping);
 
   //serialize out the cache index
   fc::datastream<size_t> dssz;
   serialize_cache_index(dssz);
   size_t sz = dssz.tellp();
 
   char* p = nullptr;
   while(_cache_index.size()) {
      p = (char*)allocator->allocate(sz);
      if(p != nullptr)
         break;
      //in theory, there could be too little free space avaiable to store the cache index
      //try to free up some space
      for(unsigned int i = 0; i < 25 && _cache_index.size(); ++i) {
         allocator->deallocate(code_mapping + _cache_index.back().code_begin);
         allocator->deallocate(code_mapping + _cache_index.back().initdata_begin);
         _cache_index.pop_back();
      }
   }
 
   if(p) {
      fc::datastream<char*> ds(p, sz);
      serialize_cache_index(ds);
 
      uintptr_t ptr_offset = p-code_mapping;
      *((uintptr_t*)(code_mapping+descriptor_ptr_from_file_start)) = ptr_offset;
   }
   else
      *((uintptr_t*)(code_mapping+descriptor_ptr_from_file_start)) = 0;
 
   msync(code_mapping, allocator->get_size(), MS_SYNC);
   munmap(code_mapping, allocator->get_size());
   close(_cache_fd);
   set_on_disk_region_dirty(false);
 
}

Here is the call graph for this function:

Member Function Documentation

check_eviction_threshold()

void sysio::chain::eosvmoc::code_cache_base::check_eviction_threshold ( size_t free_bytes )

protected

Definition at line 380 of file code_cache.cpp.

                                                                {
   if(free_bytes < _free_bytes_eviction_threshold)
      run_eviction_round();
}

Here is the call graph for this function:

Here is the caller graph for this function:

fd()

const int & sysio::chain::eosvmoc::code_cache_base::fd ( ) const

inline

Definition at line 44 of file code_cache.hpp.

{ return _cache_fd; }

Here is the caller graph for this function:

free_code()

void sysio::chain::eosvmoc::code_cache_base::free_code	(	const digest_type &	code_id,
		const uint8_t &	vm_version )

Definition at line 353 of file code_cache.cpp.

                                                                                     {
   code_cache_index::index<by_hash>::type::iterator it = _cache_index.get<by_hash>().find(boost::make_tuple(code_id, vm_version));
   if(it != _cache_index.get<by_hash>().end()) {
      write_message_with_fds(_compile_monitor_write_socket, evict_wasms_message{ {*it} });
      _cache_index.get<by_hash>().erase(it);
   }
 
   //if it's in the queued list, erase it
   _queued_compiles.erase({code_id, vm_version});
 
   //however, if it's currently being compiled there is no way to cancel the compile,
   //so instead set a poison boolean that indicates not to insert the code in to the cache
   //once the compile is complete
   const std::unordered_map<code_tuple, bool>::iterator compiling_it = _outstanding_compiles_and_poison.find({code_id, vm_version});
   if(compiling_it != _outstanding_compiles_and_poison.end())
      compiling_it->second = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_eviction_round()

void sysio::chain::eosvmoc::code_cache_base::run_eviction_round ( )

protected

Definition at line 371 of file code_cache.cpp.

                                         {
   evict_wasms_message evict_msg;
   for(unsigned int i = 0; i < 25 && _cache_index.size() > 1; ++i) {
      evict_msg.codes.emplace_back(_cache_index.back());
      _cache_index.pop_back();
   }
   write_message_with_fds(_compile_monitor_write_socket, evict_msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_cache_index()

template<typename T >

void sysio::chain::eosvmoc::code_cache_base::serialize_cache_index ( fc::datastream< T > & ds )

protected

Definition at line 299 of file code_cache.cpp.

                                                               {
   unsigned entries = _cache_index.size();
   fc::raw::pack(ds, entries);
   for(const code_descriptor& cd : _cache_index)
      fc::raw::pack(ds, cd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_on_disk_region_dirty()

void sysio::chain::eosvmoc::code_cache_base::set_on_disk_region_dirty ( bool dirty )

protected

Definition at line 289 of file code_cache.cpp.

                                                         {
   bip::file_mapping dirty_mapping(_cache_file_path.generic_string().c_str(), bip::read_write);
   bip::mapped_region dirty_region(dirty_mapping, bip::read_write);
 
   *((char*)dirty_region.get_address()+header_dirty_bit_offset_from_file_start) = dirty;
   if(dirty_region.flush(0, 0, false) == false)
      elog("Syncing code cache failed");
}

Here is the caller graph for this function:

Member Data Documentation

_cache_fd

int sysio::chain::eosvmoc::code_cache_base::_cache_fd

protected

Definition at line 68 of file code_cache.hpp.

_cache_file_path

bfs::path sysio::chain::eosvmoc::code_cache_base::_cache_file_path

protected

Definition at line 67 of file code_cache.hpp.

_cache_index

code_cache_index sysio::chain::eosvmoc::code_cache_base::_cache_index

protected

Definition at line 63 of file code_cache.hpp.

_compile_monitor_read_socket

local::datagram_protocol::socket sysio::chain::eosvmoc::code_cache_base::_compile_monitor_read_socket {_ctx}

protected

Definition at line 72 of file code_cache.hpp.

{_ctx};

_compile_monitor_write_socket

local::datagram_protocol::socket sysio::chain::eosvmoc::code_cache_base::_compile_monitor_write_socket {_ctx}

protected

Definition at line 71 of file code_cache.hpp.

{_ctx};

_ctx

io_context sysio::chain::eosvmoc::code_cache_base::_ctx

protected

Definition at line 70 of file code_cache.hpp.

_db

const chainbase::database& sysio::chain::eosvmoc::code_cache_base::_db

protected

Definition at line 65 of file code_cache.hpp.

_free_bytes_eviction_threshold

size_t sysio::chain::eosvmoc::code_cache_base::_free_bytes_eviction_threshold

protected

Definition at line 79 of file code_cache.hpp.

_outstanding_compiles_and_poison

std::unordered_map<code_tuple, bool> sysio::chain::eosvmoc::code_cache_base::_outstanding_compiles_and_poison

protected

Definition at line 77 of file code_cache.hpp.

_queued_compiles

std::unordered_set<code_tuple> sysio::chain::eosvmoc::code_cache_base::_queued_compiles

protected

Definition at line 76 of file code_cache.hpp.

---

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

• libraries/chain/include/sysio/chain/webassembly/sys-vm-oc/code_cache.hpp
• libraries/chain/webassembly/runtimes/sys-vm-oc/code_cache.cpp