jit_executor Namespace Reference

Namespaces
namespace	anonymous_namespace{jit_executor_component.cc}
namespace	anonymous_namespace{jit_executor_javascript.cc}
namespace	anonymous_namespace{jit_executor_plugin.cc}
namespace	db

Classes
struct	Code
class	CommonContext
	Specialization of the Polyglot_common_context to provide MRS specific logging functions as well as the MRS specific engine to be used across the different contexts. More...
class	ContextPool
class	DebugContextHandle
struct	GlobalCallbacks
struct	GlobalConfig
class	IContext
class	IContextHandle
	Base handler for Jit Executor Context instances. More...
class	IServiceHandlers
	Interface defining central location for the handlers associated to a database service. More...
class	JavaScript
	MRS JavaScript Implementation. More...
class	JavaScriptContext
class	JitExecutorComponent
	Registry of graal contexts to be used by each service. More...
class	MemoryError
class	PluginConfig
class	Pool
	Generic implementation of a pool. More...
class	PooledContextHandle
	A wrapper that will return a context to the pool as soon as it is released. More...
struct	Result
struct	ServiceHandlerConfig
class	ServiceHandlers
	Contains the handlers to be used to attend JavaScript processing requests for a specific service. More...
class	TimeoutError

Typedefs
using	Value_type = shcore::Value_type
using	Scoped_global = shcore::polyglot::Scoped_global
using	Value = shcore::Value
using	Dictionary_t = shcore::Dictionary_t
using	Polyglot_error = shcore::polyglot::Polyglot_error
using	IFile_system = shcore::polyglot::IFile_system

Enumerations
enum class	ResultType { Json , Raw }
enum class	ResultState { Ok , Error , ResourceExhausted }
enum class	ProcessingState { Idle , Processing , Finished }

Functions
static void	init (mysql_harness::PluginFuncEnv *env)
static void	deinit (mysql_harness::PluginFuncEnv *)
static void	expose_configuration (mysql_harness::PluginFuncEnv *env, const char *, bool initial)

Variables
static const uint64_t	k_default_pool_size = 8
constexpr const char	kMaxContextPoolSize [] {"max_context_pool_size"}
	NOTE: Not being used ATM, the idea was to create a pool of contexts of up to max_context_pool_size per service, however, that only made sense if it was possible to i.e. More...
static constexpr std::array	options
static constexpr std::string_view	kSectionName {"jit_executor"}
static constexpr uint32_t	kDefaultMaxGraalVMContexts {8}
static constexpr std::array	required
mysql_harness::Plugin JIT_EXECUTOR_PLUGIN_EXPORT	harness_plugin_jit_executor

Typedef Documentation

Dictionary_t

typedef shcore::Dictionary_t jit_executor::Dictionary_t

IFile_system

typedef shcore::polyglot::IFile_system jit_executor::IFile_system

Polyglot_error

using jit_executor::Polyglot_error = typedef shcore::polyglot::Polyglot_error

Scoped_global

using jit_executor::Scoped_global = typedef shcore::polyglot::Scoped_global

Value

using jit_executor::Value = typedef shcore::Value

Value_type

using jit_executor::Value_type = typedef shcore::Value_type

Enumeration Type Documentation

ProcessingState

enum class jit_executor::ProcessingState

strong

Enumerator
Idle
Processing
Finished

ResultState

enum class jit_executor::ResultState

strong

Enumerator
Ok
Error
ResourceExhausted

ResultType

enum class jit_executor::ResultType

strong

Enumerator
Json
Raw

Function Documentation

deinit()

static void jit_executor::deinit ( mysql_harness::PluginFuncEnv *  )

static

expose_configuration()

static void jit_executor::expose_configuration ( mysql_harness::PluginFuncEnv *  env, const char *  , bool  initial  )

static

init()

static void jit_executor::init ( mysql_harness::PluginFuncEnv *  env )

static

Variable Documentation

harness_plugin_jit_executor

mysql_harness::Plugin JIT_EXECUTOR_PLUGIN_EXPORT jit_executor::harness_plugin_jit_executor

Initial value:

= {
    mysql_harness::PLUGIN_ABI_VERSION,       
    mysql_harness::ARCHITECTURE_DESCRIPTOR,  
    "jit_executor",                          
    VERSION_NUMBER(0, 0, 1),
    
    required.size(),
    required.data(),
    
    0,
    nullptr,
    init,     
    deinit,   
    nullptr,  
    nullptr,  
    false,    
    options.size(),
    options.data(),
    expose_configuration,
}

k_default_pool_size

const uint64_t jit_executor::k_default_pool_size = 8

static

kDefaultMaxGraalVMContexts

constexpr uint32_t jit_executor::kDefaultMaxGraalVMContexts {8}

staticconstexpr

kMaxContextPoolSize

constexpr const char jit_executor::kMaxContextPoolSize[] {"max_context_pool_size"}

constexpr

NOTE: Not being used ATM, the idea was to create a pool of contexts of up to max_context_pool_size per service, however, that only made sense if it was possible to i.e.

create a base context to be used on an execution and then reset it to the original state, however that is NOT possible. The proposed solution seems to be using shared engine and simply create the contexts as needed.

kSectionName

constexpr std::string_view jit_executor::kSectionName {"jit_executor"}

staticconstexpr

options

constexpr std::array jit_executor::options

staticconstexpr

Initial value:

{
    kMaxContextPoolSize,
}

required

constexpr std::array jit_executor::required

staticconstexpr

Initial value:

{
    "logger",
    "io",
}