gboolean
te_graph_trigger(gpointer user_data)
{
enum transition_status graph_rc = -1;
if (transition_graph == NULL) {
crm_debug("Nothing to do");
return TRUE;
}
crm_trace("Invoking graph %d in state %s", transition_graph->id, fsa_state2string(fsa_state));
switch (fsa_state) {
case S_STARTING:
case S_PENDING:
case S_NOT_DC:
case S_HALT:
case S_ILLEGAL:
case S_STOPPING:
case S_TERMINATE:
return TRUE;
break;
default:
break;
}
if (transition_graph->complete == FALSE) {
int limit = transition_graph->batch_limit;
transition_graph->batch_limit = throttle_get_total_job_limit(limit);
graph_rc = run_graph(transition_graph);
transition_graph->batch_limit = limit; /* Restore the configured value */
/* significant overhead... */
/* print_graph(LOG_DEBUG_3, transition_graph); */
if (graph_rc == transition_active) {
crm_trace("Transition not yet complete");
return TRUE;
} else if (graph_rc == transition_pending) {
crm_trace("Transition not yet complete - no actions fired");
return TRUE;
}
if (graph_rc != transition_complete) {
crm_warn("Transition failed: %s", transition_status(graph_rc));
print_graph(LOG_NOTICE, transition_graph);
}
}
crm_debug("Transition %d is now complete", transition_graph->id);
transition_graph->complete = TRUE;
notify_crmd(transition_graph);
return TRUE;
}
gboolean
te_graph_trigger(gpointer user_data)
{
enum transition_status graph_rc = -1;
if (transition_graph == NULL) {
crm_debug("Nothing to do");
return TRUE;
}
crm_debug_2("Invoking graph %d in state %s", transition_graph->id, fsa_state2string(fsa_state));
switch (fsa_state) {
case S_STARTING:
case S_PENDING:
case S_NOT_DC:
case S_HALT:
case S_ILLEGAL:
case S_STOPPING:
case S_TERMINATE:
return TRUE;
break;
default:
break;
}
if (transition_graph->complete == FALSE) {
graph_rc = run_graph(transition_graph);
print_graph(LOG_DEBUG_3, transition_graph);
if (graph_rc == transition_active) {
crm_debug_3("Transition not yet complete");
return TRUE;
} else if (graph_rc == transition_pending) {
crm_debug_3("Transition not yet complete - no actions fired");
return TRUE;
}
if (graph_rc != transition_complete) {
crm_err("Transition failed: %s", transition_status(graph_rc));
print_graph(LOG_WARNING, transition_graph);
}
}
crm_info("Transition %d is now complete", transition_graph->id);
transition_graph->complete = TRUE;
notify_crmd(transition_graph);
return TRUE;
}
static void run_graphs(MSTicker *s, MSList *execution_list, bool_t force_schedule){
MSList *it;
MSList *unschedulable=NULL;
for(it=execution_list;it!=NULL;it=it->next){
run_graph((MSFilter*)it->data,s,&unschedulable,force_schedule);
}
/* filters that are part of a loop haven't been called in process() because one of their input refers to a filter that could not be scheduled (because they could not be scheduled themselves)... Do you understand ?*/
/* we resolve this by simply assuming that they must be called anyway
for the loop to run correctly*/
/* we just recall run_graphs on them, as if they were source filters */
if (unschedulable!=NULL) {
run_graphs(s,unschedulable,TRUE);
ms_list_free(unschedulable);
}
}
static void
process_next_job(void* data)
{
crm_graph_t *transition = (crm_graph_t *)data;
enum transition_status graph_rc;
qb_enter();
if (!graph_updated) {
qb_loop_job_add(NULL, QB_LOOP_MED, transition, process_next_job);
qb_leave();
return;
}
graph_updated = FALSE;
graph_rc = run_graph(transition);
qb_log(LOG_DEBUG, "run_graph returned: %s", transition_status(graph_rc));
if (graph_rc == transition_active || graph_rc == transition_pending) {
qb_loop_job_add(NULL, QB_LOOP_MED, transition, process_next_job);
qb_leave();
return;
}
if (graph_rc != transition_complete) {
qb_log(LOG_ERR, "Transition failed: %s",
transition_status(graph_rc));
}
destroy_graph(transition);
// we don't want to free the input xml
working_set->input = NULL;
cleanup_alloc_calculations(working_set);
free(working_set);
working_set = NULL;
completed_fn(run_user_data, graph_rc);
qb_leave();
return;
}
static void run_graph(MSFilter *f, MSTicker *s, MSList **unschedulable, bool_t force_schedule){
int i;
MSQueue *l;
if (f->last_tick!=s->ticks ){
if (filter_can_process(f,s->ticks) || force_schedule) {
/* this is a candidate */
f->last_tick=s->ticks;
call_process(f);
/* now recurse to next filters */
for(i=0;i<f->desc->noutputs;i++){
l=f->outputs[i];
if (l!=NULL){
run_graph(l->next.filter,s,unschedulable, force_schedule);
}
}
}else{
/* this filter has not all inputs that have been filled by filters before it. */
*unschedulable=ms_list_prepend(*unschedulable,f);
}
}
}
int main(void)
{
init();
while (1)
{
// keep the clock ticking
run_rtc();
// run volts/amps/temperature reading stuff on the onewire interface
run_measure();
// decide if inverter or shunt load is needed to be turned on
run_control();
// keep the log data in dataflash up to date
run_log();
// calculate turbine RPM from period of raw AC
run_rpm();
// save values for graphic display of power in/out
run_graph();
// display stuff on the LCD & get user input
run_ui();
}
}
int main(int argc, char *argv[])
{
const std::string root_path = get_root_path();
std::string proto_file;
std::string model_file;
std::string image_file;
std::string save_name="save.jpg";
const char * device=nullptr;
int res;
while( ( res=getopt(argc,argv,"p:m:i:hd:"))!= -1)
{
switch(res)
{
case 'p':
proto_file=optarg;
break;
case 'm':
model_file=optarg;
break;
case 'i':
image_file=optarg;
break;
case 'd':
device=optarg;
break;
case 'h':
std::cout << "[Usage]: " << argv[0] << " [-h]\n"
<< " [-p proto_file] [-m model_file] [-i image_file]\n";
return 0;
default:
break;
}
}
const char *model_name = "mssd_300";
if(proto_file.empty())
{
proto_file = root_path + DEF_PROTO;
std::cout<< "proto file not specified,using "<<proto_file<< " by default\n";
}
if(model_file.empty())
{
model_file = root_path + DEF_MODEL;
std::cout<< "model file not specified,using "<<model_file<< " by default\n";
}
if(image_file.empty())
{
image_file = root_path + DEF_IMAGE;
std::cout<< "image file not specified,using "<<image_file<< " by default\n";
}
// init tengine
init_tengine_library();
if (request_tengine_version("0.1") < 0)
return 1;
if (load_model(model_name, "caffe", proto_file.c_str(), model_file.c_str()) < 0)
return 1;
std::cout << "load model done!\n";
// create graph
graph_t graph = create_runtime_graph("graph", model_name, NULL);
if (!check_graph_valid(graph))
{
std::cout << "create graph0 failed\n";
return 1;
}
if(device!=nullptr)
{
set_graph_device(graph,device);
}
//dump_graph(graph);
// input
int img_h = 300;
int img_w = 300;
int img_size = img_h * img_w * 3;
float *input_data = (float *)malloc(sizeof(float) * img_size);
int node_idx=0;
int tensor_idx=0;
tensor_t input_tensor = get_graph_input_tensor(graph, node_idx, tensor_idx);
if(!check_tensor_valid(input_tensor))
{
printf("Get input node failed : node_idx: %d, tensor_idx: %d\n",node_idx,tensor_idx);
return 1;
}
int dims[] = {1, 3, img_h, img_w};
set_tensor_shape(input_tensor, dims, 4);
prerun_graph(graph);
int repeat_count = 1;
const char *repeat = std::getenv("REPEAT_COUNT");
if (repeat)
repeat_count = std::strtoul(repeat, NULL, 10);
//warm up
get_input_data_ssd(image_file, input_data, img_h, img_w);
set_tensor_buffer(input_tensor, input_data, img_size * 4);
run_graph(graph, 1);
struct timeval t0, t1;
float total_time = 0.f;
for (int i = 0; i < repeat_count; i++)
{
get_input_data_ssd(image_file, input_data, img_h, img_w);
gettimeofday(&t0, NULL);
set_tensor_buffer(input_tensor, input_data, img_size * 4);
run_graph(graph, 1);
gettimeofday(&t1, NULL);
float mytime = (float)((t1.tv_sec * 1000000 + t1.tv_usec) - (t0.tv_sec * 1000000 + t0.tv_usec)) / 1000;
total_time += mytime;
}
std::cout << "--------------------------------------\n";
std::cout << "repeat " << repeat_count << " times, avg time per run is " << total_time / repeat_count << " ms\n";
tensor_t out_tensor = get_graph_output_tensor(graph, 0,0);//"detection_out");
int out_dim[4];
get_tensor_shape( out_tensor, out_dim, 4);
float *outdata = (float *)get_tensor_buffer(out_tensor);
int num=out_dim[1];
float show_threshold=0.5;
post_process_ssd(image_file,show_threshold, outdata, num,save_name);
put_graph_tensor(out_tensor);
put_graph_tensor(input_tensor);
postrun_graph(graph);
free(input_data);
destroy_runtime_graph(graph);
remove_model(model_name);
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 4)
{
std::cout << "[Usage]: " << argv[0] << " <proto> <caffemodel> <size> \n";
return 0;
}
// init tengine
init_tengine_library();
if (request_tengine_version("0.1") < 0)
return 1;
// load model
const char *model_name = "test";
std::string proto_name_ =argv[1];
std::string mdl_name_ = argv[2];
if (load_model(model_name, "caffe", proto_name_.c_str(), mdl_name_.c_str()) < 0)
return 1;
std::cout << "load model done!\n";
// create graph
graph_t graph = create_runtime_graph("graph", model_name, NULL);
if (!check_graph_valid(graph))
{
std::cout << "create graph0 failed\n";
return 1;
}
// input
int img_h = atoi(argv[3]);
int img_w = img_h;
if (argc==5) img_w=atoi(argv[4]);
int img_size = img_h * img_w * 3;
float *input_data = (float *)malloc(sizeof(float) * img_size);
for(int i=0;i<img_size;i++)
input_data[i]=(i%123)*0.017;
int node_idx = 0;
int tensor_idx = 0;
tensor_t input_tensor=get_graph_input_tensor(graph , node_idx , tensor_idx );
int dims[] = {1, 3, img_h, img_w};
set_tensor_shape(input_tensor, dims, 4);
prerun_graph(graph);
int repeat_count = 1;
const char *repeat = std::getenv("REPEAT_COUNT");
if (repeat)
repeat_count = std::strtoul(repeat, NULL, 10);
struct timeval t0, t1;
float avg_time = 0.f;
set_tensor_buffer(input_tensor, input_data, img_size * 4);
gettimeofday(&t0, NULL);
for (int i = 0; i < repeat_count; i++)
run_graph(graph, 1);
gettimeofday(&t1, NULL);
float mytime = (float)((t1.tv_sec * 1000000 + t1.tv_usec) - (t0.tv_sec * 1000000 + t0.tv_usec)) / 1000;
avg_time += mytime;
std::cout << "--------------------------------------\n";
std::cout << "repeat " << repeat_count << " times, avg time per run is " << avg_time / repeat_count << " ms\n";
put_graph_tensor(input_tensor);
free(input_data);
postrun_graph(graph);
destroy_runtime_graph(graph);
remove_model(model_name);
std::cout << "ALL TEST DONE\n";
release_tengine_library();
return 0;
}
