void heston_kernel_ml(const params_ml params, hls::stream<calc_t> &gaussian_rn1,
hls::stream<calc_t> &gaussian_rn2, hls::stream<calc_t> &prices) {
#pragma HLS interface ap_none port=params
#pragma HLS resource core=AXI4LiteS metadata="-bus_bundle params" \
variable=params
#pragma HLS interface ap_fifo port=gaussian_rn1
#pragma HLS resource core=AXI4Stream variable=gaussian_rn1
#pragma HLS interface ap_fifo port=gaussian_rn2
#pragma HLS resource core=AXI4Stream variable=gaussian_rn2
#pragma HLS interface ap_fifo port=prices
#pragma HLS resource core=AXI4Stream variable=prices
#pragma HLS resource core=AXI4LiteS metadata="-bus_bundle params" \
variable=return
// write block size to stream
prices.write(BLOCK_SIZE);
state_t state_coarse[BLOCK_SIZE];
#pragma HLS data_pack variable=state_coarse
state_t state_fine[BLOCK_SIZE];
#pragma HLS data_pack variable=state_fine
w_both_t w_both[BLOCK_SIZE];
#pragma HLS data_pack variable=w_both
ap_uint<6> upper_j = params.ml_constant + (params.do_multilevel ? 1 : 0);
for (uint32_t path = 0; path < params.path_cnt; path += BLOCK_SIZE) {
for (uint32_t step = 0; step != params.step_cnt_coarse; ++step) {
for (ap_uint<6> j = 0; j != upper_j; ++j) {
for (ap_uint<10> block_i = 0; block_i != BLOCK_SIZE;
++block_i) {
#pragma HLS PIPELINE II=1
bool is_fine = j != params.ml_constant;
//
// initialize
//
state_t l_state_coarse, l_state_fine;
w_both_t l_w_both;
if (step == 0 && j == 0) {
l_state_coarse = get_init_state(params);
l_state_fine = get_init_state(params);
l_w_both = get_w_zero();
} else {
l_state_coarse = state_coarse[block_i];
l_state_fine = state_fine[block_i];
l_w_both = w_both[block_i];
}
//
// calculate next step
//
state_t n_state_coarse, n_state_fine;
w_both_t n_w_both;
if (is_fine) {
// step fine
float w_stock = gaussian_rn1.read();
float w_vola = gaussian_rn2.read();
n_state_fine = get_next_step(params, l_state_fine,
w_stock, w_vola, true);
n_state_coarse = l_state_coarse;
// accumulate random numbers
n_w_both.w_stock = l_w_both.w_stock + w_stock;
n_w_both.w_vola = l_w_both.w_vola + w_vola;
} else {
// step coarse
n_state_coarse = get_next_step(params, l_state_coarse,
l_w_both.w_stock, l_w_both.w_vola, false);
n_state_fine = l_state_fine;
n_w_both = get_w_zero();
}
state_coarse[block_i] = n_state_coarse;
state_fine[block_i] = n_state_fine;
w_both[block_i] = n_w_both;
//
// write out
//
if ((step + 1 == params.step_cnt_coarse) &&
(j + 1 >= params.ml_constant)) {
if (is_fine) {
prices.write(get_log_price(n_state_fine));
} else {
prices.write(get_log_price(n_state_coarse));
}
}
}
}
}
}
}
/**
* Exceute the static initializer if required. Note that the ret address used
* here is set such that the current instruction will be re-started when the
* initialization completes.
* @return An indication of how the VM should proceed
*/
int dispatch_static_initializer (ClassRecord *aRec, byte *retAddr)
{
int state = get_init_state(aRec);
ClassRecord *init = aRec;
ClassRecord *super = get_class_record(init->parentClass);
MethodRecord *method;
// Are we needed?
if (state & C_INITIALIZED) return EXEC_CONTINUE;
// We need to initialize all of the super classes first. So we find the
// highest one that has not been initialized and deal with that. This code
// will then be called again and we will init the next highest and so on
// until all of the classes in the chain are done.
for(;;)
{
// find first super class that has not been initialized
while (init != super && (get_init_state(super) & C_INITIALIZED) == 0)
{
init = super;
super = get_class_record(init->parentClass);
}
// Do we have an initilizer if so we have found our class
if (has_clinit (init)) break;
// no initializer so mark as now initialized
set_init_state (init, C_INITIALIZED);
// If we are at the start of the list we are done
if (init == aRec) return EXEC_CONTINUE;
// Otherwise go do it all again
init = aRec;
}
state = get_init_state(init);
// are we already initializing ?
if (state & C_INITIALIZING)
{
// Is it this thread that is doing the init?
if (get_sync(init)->threadId == currentThread->threadId)
return EXEC_CONTINUE;
// No so we must retry the current instruction
curPc = retAddr;
sleep_thread(1);
schedule_request(REQUEST_SWITCH_THREAD);
return EXEC_RETRY;
}
#if DEBUG_METHODS
printf ("dispatch_static_initializer: has clinit: %d, %d\n",
(int) aRec, (int) retAddr);
#endif
// Static initializer is always the first method
method = get_method_table(init);
if ((byte *)method == get_binary_base() || method->signatureId != _6clinit_7_4_5V)
{
throw_new_exception (JAVA_LANG_NOSUCHMETHODERROR);
return EXEC_EXCEPTION;
}
// Can we run it?
if (!dispatch_special (method, retAddr))
return EXEC_RETRY;
// Mark for next time
set_init_state(init, C_INITIALIZING);
// and claim the monitor
current_stackframe()->monitor = (Object *)init;
enter_monitor (currentThread, (Object *)init);
return EXEC_RUN;
}
