Fleet  0.0.9 Inference in the LOT
VirtualMachinePool< VirtualMachineState_t > Class Template Reference

#include <VirtualMachinePool.h>

Inheritance diagram for VirtualMachinePool< VirtualMachineState_t >:
[legend]
Collaboration diagram for VirtualMachinePool< VirtualMachineState_t >:
[legend]

## Public Types

typedef VirtualMachineState_t::output_t output_t

typedef VirtualMachineState_t::input_t input_t

## Public Member Functions

VirtualMachinePool ()

virtual ~VirtualMachinePool ()

virtual void clear ()
Remove everything and reset my values. More...

Returns true if I would add something with this lp, given my MAX_STEPS and the stack. This lets us speed up by checking if we would add before copying/constructing a VMS. More...

void push (VirtualMachineState_t *o)
Add the VirtualMachineState_t o to this pool (but again checking if I'd add) More...

template<typename T >
bool copy_increment_push (const VirtualMachineState_t *x, T v, double lpinc)
This is an important opimization where we will make a copy of x, push v into it's stack, and increment its lp by lpinc only if it will be added to the queue, which we check in the pool here. This saves us from having to use the VirtualMachineState constructor (e.g. making a copy, which is expensive if we are copying all the stacks) if the copy won't actually be added to the queue. More...

template<typename T >
bool increment_push (VirtualMachineState_t *s, T v, double lpinc)
Same as copy_increment_push, but does not make a copy – just add. More...

DiscreteDistribution< output_trun ()
This runs and adds up the probability mass for everything, returning a dictionary outcomes->log_probabilities. This is the main running loop, which pops frmo the top of our queue, runs, and continues until we've done enough or all. Note that objects lower than min_lp are not ever pushed onto the queue. More...

std::vector< VirtualMachineState_t > run_vms ()
Run but return a vector of completed virtual machines instead of marginalizing outputs. You might want this if you needed to separate execution paths, or wanted to access runtime counts. This also can get joint distributions on outputs by running a VirtualMachineState multiple times. More...

## Public Attributes

unsigned long total_vms_steps

double worst_lp

unsigned long total_instruction_count

std::priority_queue< VirtualMachineState_t *, std::vector< VirtualMachineState_t * >, VirtualMachinePool::compare_VirtualMachineState_t_prt > Q

Static Public Attributes inherited from VirtualMachineControl
static unsigned long MAX_RECURSE = 64

static unsigned long MAX_RUN_PROGRAM = 1024

static unsigned long MAX_STEPS = 512

static unsigned long MAX_OUTPUTS = 512

static double MIN_LP = -10

Date
02/02/20

## ◆ input_t

template<typename VirtualMachineState_t>
 typedef VirtualMachineState_t::input_t VirtualMachinePool< VirtualMachineState_t >::input_t

## ◆ output_t

template<typename VirtualMachineState_t>
 typedef VirtualMachineState_t::output_t VirtualMachinePool< VirtualMachineState_t >::output_t

## ◆ VirtualMachinePool()

template<typename VirtualMachineState_t>
 VirtualMachinePool< VirtualMachineState_t >::VirtualMachinePool ( )
inline

## ◆ ~VirtualMachinePool()

template<typename VirtualMachineState_t>
 virtual VirtualMachinePool< VirtualMachineState_t >::~VirtualMachinePool ( )
inlinevirtual

## ◆ clear()

template<typename VirtualMachineState_t>
 virtual void VirtualMachinePool< VirtualMachineState_t >::clear ( )
inlinevirtual

Remove everything and reset my values.

## ◆ copy_increment_push()

template<typename VirtualMachineState_t>
template<typename T >
 bool VirtualMachinePool< VirtualMachineState_t >::copy_increment_push ( const VirtualMachineState_t * x, T v, double lpinc )
inline

This is an important opimization where we will make a copy of x, push v into it's stack, and increment its lp by lpinc only if it will be added to the queue, which we check in the pool here. This saves us from having to use the VirtualMachineState constructor (e.g. making a copy, which is expensive if we are copying all the stacks) if the copy won't actually be added to the queue.

Parameters
 x v lpinc
Returns

## ◆ increment_push()

template<typename VirtualMachineState_t>
template<typename T >
 bool VirtualMachinePool< VirtualMachineState_t >::increment_push ( VirtualMachineState_t * s, T v, double lpinc )
inline

Same as copy_increment_push, but does not make a copy – just add.

Parameters
 s v lpinc
Returns

## ◆ push()

template<typename VirtualMachineState_t>
 void VirtualMachinePool< VirtualMachineState_t >::push ( VirtualMachineState_t * o )
inline

Add the VirtualMachineState_t o to this pool (but again checking if I'd add)

Parameters
 o

## ◆ run()

template<typename VirtualMachineState_t>
 DiscreteDistribution VirtualMachinePool< VirtualMachineState_t >::run ( )
inline

This runs and adds up the probability mass for everything, returning a dictionary outcomes->log_probabilities. This is the main running loop, which pops frmo the top of our queue, runs, and continues until we've done enough or all. Note that objects lower than min_lp are not ever pushed onto the queue.

Parameters
Returns

HMM Do we want to count these too? I guess since its called "total"....

## ◆ run_vms()

template<typename VirtualMachineState_t>
 std::vector VirtualMachinePool< VirtualMachineState_t >::run_vms ( )
inline

Run but return a vector of completed virtual machines instead of marginalizing outputs. You might want this if you needed to separate execution paths, or wanted to access runtime counts. This also can get joint distributions on outputs by running a VirtualMachineState multiple times.

Parameters
Returns

template<typename VirtualMachineState_t>
 bool VirtualMachinePool< VirtualMachineState_t >::wouldIadd ( double lp )
inline

Returns true if I would add something with this lp, given my MAX_STEPS and the stack. This lets us speed up by checking if we would add before copying/constructing a VMS.

Parameters
 lp
Returns

## ◆ Q

template<typename VirtualMachineState_t>
 std::priority_queue, VirtualMachinePool::compare_VirtualMachineState_t_prt> VirtualMachinePool< VirtualMachineState_t >::Q

## ◆ total_instruction_count

template<typename VirtualMachineState_t>
 unsigned long VirtualMachinePool< VirtualMachineState_t >::total_instruction_count

## ◆ total_vms_steps

template<typename VirtualMachineState_t>
 unsigned long VirtualMachinePool< VirtualMachineState_t >::total_vms_steps

## ◆ worst_lp

template<typename VirtualMachineState_t>
 double VirtualMachinePool< VirtualMachineState_t >::worst_lp

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