sysio::chain::eosvmoc::code_cache_sync Class Reference

#include <code_cache.hpp>

Inheritance diagram for sysio::chain::eosvmoc::code_cache_sync:

Collaboration diagram for sysio::chain::eosvmoc::code_cache_sync:

Public Member Functions
	~code_cache_sync ()
const code_descriptor *const	get_descriptor_for_code_sync (const digest_type &code_id, const uint8_t &vm_version)
	code_cache_base (const bfs::path data_dir, const eosvmoc::config &eosvmoc_config, const chainbase::database &db)
Public Member Functions inherited from sysio::chain::eosvmoc::code_cache_base
	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)

Additional Inherited Members
Protected Types inherited from sysio::chain::eosvmoc::code_cache_base
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 inherited from sysio::chain::eosvmoc::code_cache_base
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 inherited from sysio::chain::eosvmoc::code_cache_base
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 108 of file code_cache.hpp.

Constructor & Destructor Documentation

~code_cache_sync()

sysio::chain::eosvmoc::code_cache_sync::~code_cache_sync

(

)

Definition at line 168 of file code_cache.cpp.

                                  {
   //it's exceedingly critical that we wait for the compile monitor to be done with all its work
   //This is easy in the sync case
   _compile_monitor_write_socket.shutdown(local::datagram_protocol::socket::shutdown_send);
   auto [success, message, fds] = read_message_with_fds(_compile_monitor_read_socket);
   if(success)
      elog("unexpected response from SYS VM OC compile monitor during shutdown");
}

Here is the call graph for this function:

Member Function 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 41 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());
}

get_descriptor_for_code_sync()

const code_descriptor *const sysio::chain::eosvmoc::code_cache_sync::get_descriptor_for_code_sync	(	const digest_type &	code_id,
		const uint8_t &	vm_version )

Definition at line 177 of file code_cache.cpp.

                                                                                                                                {
   //check for entry in cache
   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()) {
      _cache_index.relocate(_cache_index.begin(), _cache_index.project<0>(it));
      return &*it;
   }
 
   const code_object* const codeobject = _db.find<code_object,by_code_hash>(boost::make_tuple(code_id, 0, vm_version));
   if(!codeobject) //should be impossible right?
      return nullptr;
 
   std::vector<wrapped_fd> fds_to_pass;
   fds_to_pass.emplace_back(memfd_for_bytearray(codeobject->code));
 
   write_message_with_fds(_compile_monitor_write_socket, compile_wasm_message{ {code_id, vm_version} }, fds_to_pass);
   auto [success, message, fds] = read_message_with_fds(_compile_monitor_read_socket);
   SYS_ASSERT(success, wasm_execution_error, "failed to read response from monitor process");
   SYS_ASSERT(std::holds_alternative<wasm_compilation_result_message>(message), wasm_execution_error, "unexpected response from monitor process");
 
   wasm_compilation_result_message result = std::get<wasm_compilation_result_message>(message);
   SYS_ASSERT(std::holds_alternative<code_descriptor>(result.result), wasm_execution_error, "failed to compile wasm");
 
   check_eviction_threshold(result.cache_free_bytes);
 
   return &*_cache_index.push_front(std::move(std::get<code_descriptor>(result.result))).first;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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