static int
primwatch_event_initialize(
primwatch_t *primwatch)
{
if ((primwatch->event_base = event_init()) == NULL) {
fprintf(stderr, "can not create event cntext\n");
return 1;
}
if (event_base_priority_init(primwatch->event_base, DEFAULT_EVENT_PRIORITY)) {
fprintf(stderr, "can not initialize event priority\n");
return 1;
}
if (watcher_create(
&primwatch->watcher,
primwatch->event_base,
primwatch->config_manager)) {
fprintf(stderr, "can not create wathcer instance\n");
return 1;
}
if (controller_create(
&primwatch->controller,
primwatch->event_base,
primwatch->watcher)) {
fprintf(stderr, "can not create controller instance\n");
return 1;
}
return 0;
}
/* Helper to create all icache and iTLB structures and attach them to core->memory. */
void core_fetch_t::create_caches() {
struct core_knobs_t* knobs = core->knobs;
char name[256];
int sets, assoc, linesize, latency, banks, bank_width, MSHR_entries;
char rp;
/* IL1 */
if (sscanf(knobs->memory.IL1_opt_str, "%[^:]:%d:%d:%d:%d:%d:%d:%c:%d", name, &sets, &assoc,
&linesize, &banks, &bank_width, &latency, &rp, &MSHR_entries) != 9)
fatal("invalid IL1 options: "
"<name:sets:assoc:linesize:banks:bank_width:latency:repl-policy:num-MSHR>\n\t(%s)",
knobs->memory.IL1_opt_str);
/* the write-related options don't matter since the IL1 will(should) never see any stores */
struct cache_t* next_level = (core->memory.DL2) ? core->memory.DL2.get() : uncore->LLC.get();
struct bus_t* next_bus = (core->memory.DL2) ? core->memory.DL2_bus.get() : uncore->LLC_bus.get();
core->memory.IL1 = cache_create(core, name, CACHE_READONLY, sets, assoc, linesize, rp, 'w', 't',
'n', banks, bank_width, latency, MSHR_entries, 4, 1, next_level,
next_bus, knobs->memory.IL1_magic_hit_rate,
knobs->memory.IL1_sample_misses, nullptr);
prefetchers_create(core->memory.IL1.get(), knobs->memory.IL1_pf);
/* ITLB */
if (sscanf(knobs->memory.ITLB_opt_str, "%[^:]:%d:%d:%d:%d:%c:%d", name, &sets, &assoc, &banks,
&latency, &rp, &MSHR_entries) != 7)
fatal("invalid ITLB options: <name:sets:assoc:banks:latency:repl-policy:num-MSHR>");
core->memory.ITLB =
cache_create(core, name, CACHE_READONLY, sets, assoc, 1, rp, 'w', 't', 'n', banks, 1,
latency, MSHR_entries, 4, 1, next_level, next_bus, -1.0, false, nullptr);
core->memory.IL1->controller =
controller_create(knobs->memory.IL1_controller_opt_str, core, core->memory.IL1.get());
core->memory.ITLB->controller =
controller_create(knobs->memory.ITLB_controller_opt_str, core, core->memory.ITLB.get());
}
/*!
epg create chain
\param[in] p_priv : epg api private data.
\param[in] task_priority : task priority for chain.
\param[in] task_stk_size : task stack size.
*/
static void epg_create_chain(epg_priv_t *p_priv,
u32 task_priority,
u32 task_stk_size)
{
controller_t *p_contrl = NULL;
chain_para_t chain_para = { 0 };
ctrl_para_t ctrl_para = { 0 };
//create controller
p_contrl = &(p_priv->controller);
ctrl_para.user_id = APP_EPG;
controller_create(p_contrl, &ctrl_para);
CHECK_FAIL_RET_VOID(p_contrl != NULL);
p_contrl->on_process_evt = epg_on_process_evt;
p_contrl->user_handle = (handle_t)p_priv;
//create chain
chain_para.p_owner = (interface_t *)&p_priv->controller;
chain_para.p_name = "epg_chain";
//chain_para.priority = task_priority;
chain_para.stk_size = task_stk_size;
p_priv->p_chain = chain_create(&chain_para);
}
BOOL create_pic_chain(pic_player_priv_t *p_priv, u32 priority, u32 index)
{
chain_t *p_f_chain = NULL;
ifilter_t *p_fsrc_filter = NULL;
ifilter_t *p_pic_filter = NULL;
ifilter_t *p_render_filter = NULL;
ipin_t *p_output_pin = NULL;
ipin_t *p_input_pin = NULL;
chain_para_t chain_para = {0};
RET_CODE ret = SUCCESS;
media_format_t format = {0};
controller_t *p_contrl = &(p_priv->p_pic[index].g_controller);
ctrl_para_t ctrl_para = {(void *)p_priv};
controller_create(p_contrl, &ctrl_para);
p_contrl->on_process_evt = on_pic_draw_end;
//create chain
chain_para.p_owner = (interface_t *)&(p_priv->p_pic[index].g_controller);
if (index)
{
chain_para.p_name = "pic_chain1";
}
else
{
chain_para.p_name = "pic_chain";
}
chain_para.priority = priority;
chain_para.stk_size = 16 * KBYTES;
p_f_chain = chain_create(&chain_para);
p_priv->p_pic[index].p_f_chain = p_f_chain;
//create filter
ret = eva_add_filter_by_id(FILE_SOURCE_FILTER, &p_fsrc_filter);
MT_ASSERT(ret == SUCCESS);
ret = eva_add_filter_by_id(JPEG_FILTER, &p_pic_filter);
MT_ASSERT(ret == SUCCESS);
ret = eva_add_filter_by_id(PIC_RENDER_FILTER, &p_render_filter);
MT_ASSERT(ret == SUCCESS);
p_priv->p_pic[index].p_source_filter = p_fsrc_filter;
p_priv->p_pic[index].p_pic_play_filter = p_pic_filter;
p_priv->p_pic[index].p_pic_render_filter = p_render_filter;
//add to chain
ret = p_f_chain->add_filter(p_f_chain, p_fsrc_filter, "source filter");
MT_ASSERT(ret == SUCCESS);
ret = p_f_chain->add_filter(p_f_chain, p_pic_filter, "pic filter");
MT_ASSERT(ret == SUCCESS);
ret = p_f_chain->add_filter(p_f_chain, p_render_filter, "render filter");
MT_ASSERT(ret == SUCCESS);
//1. >>-------------link source filter and jpeg filter ------------------------>>>>
//get source pin
ret = p_fsrc_filter->get_unconnect_pin(p_fsrc_filter, OUTPUT_PIN, &p_output_pin);
MT_ASSERT(ret == SUCCESS);
MT_ASSERT(p_output_pin != NULL);
//get jpeg filter input pin
ret = p_pic_filter->get_unconnect_pin(p_pic_filter, INPUT_PIN, &p_input_pin);
MT_ASSERT(ret == SUCCESS);
MT_ASSERT(p_input_pin != NULL);
ret = p_f_chain->connect(p_f_chain, p_output_pin, p_input_pin, NULL);
MT_ASSERT(ret == SUCCESS);
//2. >>-------------link jpeg filter and render filter ------------------------>>>>
//get jpeg filter output pin
ret = p_pic_filter->get_unconnect_pin(p_pic_filter, OUTPUT_PIN, &p_output_pin);
MT_ASSERT(ret == SUCCESS);
MT_ASSERT(p_output_pin != NULL);
//get render pin
ret = p_render_filter->get_unconnect_pin(p_render_filter, INPUT_PIN, &p_input_pin);
MT_ASSERT(ret == SUCCESS);
MT_ASSERT(p_input_pin != NULL);
ret = p_f_chain->connect(p_f_chain, p_output_pin, p_input_pin, &format);
MT_ASSERT(ret == SUCCESS);
return TRUE;
}
