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; }