#include <code_cache.hpp>

Inheritance diagram for sysio::chain::eosvmoc::code_cache_async:

Collaboration diagram for sysio::chain::eosvmoc::code_cache_async:

[legend]

Public Member Functions
	code_cache_async (const bfs::path data_dir, const eosvmoc::config &eosvmoc_config, const chainbase::database &db)

	~code_cache_async ()

const code_descriptor *const	get_descriptor_for_code (const digest_type &code_id, const uint8_t &vm_version)

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 89 of file code_cache.hpp.

Constructor & Destructor Documentation

◆ code_cache_async()

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

Definition at line 42 of file code_cache.cpp.

                                                                                                                           :
   code_cache_base(data_dir, eosvmoc_config, db),
   _result_queue(eosvmoc_config.threads * 2),
   _threads(eosvmoc_config.threads)
{
   FC_ASSERT(_threads, "SYS VM OC requires at least 1 compile thread");
 
   wait_on_compile_monitor_message();
 
   _monitor_reply_thread = std::thread([this]() {
      fc::set_os_thread_name("oc-monitor");
      _ctx.run();
   });
}

Here is the call graph for this function:

◆ ~code_cache_async()

sysio::chain::eosvmoc::code_cache_async::~code_cache_async ( )

Definition at line 57 of file code_cache.cpp.

                                    {
   _compile_monitor_write_socket.shutdown(local::datagram_protocol::socket::shutdown_send);
   _monitor_reply_thread.join();
   consume_compile_thread_queue();
}

Member Function Documentation

◆ get_descriptor_for_code()

const code_descriptor *const sysio::chain::eosvmoc::code_cache_async::get_descriptor_for_code	(	const digest_type &	code_id,
		const uint8_t &	vm_version )

Definition at line 109 of file code_cache.cpp.

                                                                                                                            {
   //if there are any outstanding compiles, process the result queue now
   if(_outstanding_compiles_and_poison.size()) {
      auto [count_processed, bytes_remaining] = consume_compile_thread_queue();
 
      if(count_processed)
         check_eviction_threshold(bytes_remaining);
 
      while(count_processed && _queued_compiles.size()) {
         auto nextup = _queued_compiles.begin();
 
         //it's not clear this check is required: if apply() was called for code then it existed in the code_index; and then
         // if we got notification of it no longer existing we would have removed it from queued_compiles
         const code_object* const codeobject = _db.find<code_object,by_code_hash>(boost::make_tuple(nextup->code_id, 0, nextup->vm_version));
         if(codeobject) {
            _outstanding_compiles_and_poison.emplace(*nextup, false);
            std::vector<wrapped_fd> fds_to_pass;
            fds_to_pass.emplace_back(memfd_for_bytearray(codeobject->code));
            FC_ASSERT(write_message_with_fds(_compile_monitor_write_socket, compile_wasm_message{ *nextup }, fds_to_pass), "SYS VM failed to communicate to OOP manager");
            --count_processed;
         }
         _queued_compiles.erase(nextup);
      }
   }
 
   //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_tuple ct = code_tuple{code_id, vm_version};
 
   if(_blacklist.find(ct) != _blacklist.end())
      return nullptr;
   if(auto it = _outstanding_compiles_and_poison.find(ct); it != _outstanding_compiles_and_poison.end()) {
      it->second = false;
      return nullptr;
   }
   if(_queued_compiles.find(ct) != _queued_compiles.end())
      return nullptr;
 
   if(_outstanding_compiles_and_poison.size() >= _threads) {
      _queued_compiles.emplace(ct);
      return nullptr;
   }
 
   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;
 
   _outstanding_compiles_and_poison.emplace(ct, false);
   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{ ct }, fds_to_pass);
   return nullptr;
}