void Damageable::default_render_health(Graphic& graphic, const Color& color, float frames_count) const { if (has_hp()) { Box health_box; health_box.set_size(50.f * get_hp() / get_default_hp(), 5.f); health_box.set_left_top( get_position().x - health_box.get_width() / 2 + get_current_speed().x * frames_count, get_position().y - get_circle().get_radius() + get_current_speed().y * frames_count ); graphic.render_box(health_box, color); } }
int machine_speed_init (actuator_t *act) { machine_state_data_t *data; unsigned long *states, *all_states; unsigned long *in_state, *out_state; int state_count, filtered_count; int core_count, i; freq_scaler_data_t *freq_data; act->data = data = malloc(sizeof(machine_state_data_t)); fail_if(!data, "cannot allocate powerstate data block"); get_actuators(&data->core_act, NULL, 16, &data->freq_acts[0], NULL); fail_if(data->core_act->max > 16, "too many cores lol"); freq_data = data->freq_acts[0]->data; core_count = get_core_count(); all_states = create_machine_states(&state_count, core_count, freq_data->freq_count, freq_data->freq_array); fail_if(!all_states, "cannot generate machine states"); qsort(all_states, state_count, STATE_SIZE(core_count), compare_states_on_speed); states = malloc(STATE_SIZE(core_count) * state_count); for (i = 0, in_state = all_states, out_state = states, filtered_count = 0; i < state_count; i++, in_state+=STATE_LEN(core_count)) { if (!redundant_state(in_state, core_count) && !drop_equivalent(in_state, i, all_states, state_count, core_count) && pareto_optimal(in_state, i, all_states, state_count, core_count) && in_state[SPEED_IDX] > 0) { #if DEBUG int j; printf("%lu\t%lu", in_state[SPEED_IDX], in_state[POWER_IDX]); for (j = 0; j < core_count; j++) printf("\t%lu", in_state[CORE_IDX(j)]); printf("\n"); #endif memmove (out_state, in_state, STATE_SIZE(core_count)); out_state += STATE_LEN(core_count); filtered_count++; } } data->state_count = state_count = filtered_count; data->states = states = realloc(states, STATE_SIZE(core_count) * state_count); free(all_states); act->min = STATE_I(states, core_count, 0)[SPEED_IDX]; act->max = STATE_I(states, core_count, state_count-1)[SPEED_IDX]; data->scratch_state = malloc(STATE_SIZE(core_count)); act->value = act->set_value = get_current_speed(act); return 0; fail: return -1; }
void show_default_screen(msg_t *msg) { LCD_GoTo(8,0); get_time_str(string_buff); LCD_WriteText(string_buff); LCD_GoTo(4, 0); LCD_WriteText("k/h \0"); int offset = 1; switch(msg->type) { case MSG_SECOND_CHANGE: offset = calculate_speed() > 99 ? 0 : 1; break; } if (offset > 0) { LCD_GoTo(0,0); LCD_WriteText(" \0"); } get_current_speed(string_buff); LCD_GoTo(offset, 0); LCD_WriteText(string_buff); }
int main(int argc, char **argv) { int n_apps = 0; int apps[16]; int err; int i; int64_t window_size; int64_t skip_until_beat = 0; int64_t last_beat = 0; heartbeat_record_t current; int core_count; int opt; int max_beats = INT_MAX; extern int actuator_count; extern actuator_t *controls; actuator_t *next_ctl; decision_function_t decision_f = machine_state_controller; int acted; /* we want to see this in realtime even when it's piped through tee */ setlinebuf(stdout); /* getting rich with stock options */ while ((opt = getopt(argc, argv, "d:")) != -1) switch (opt) { case 'd': if (strcmp(optarg, "core_heuristics") == 0) decision_f = core_heuristics; else if (strcmp(optarg, "freq_heuristics") == 0) decision_f = freq_heuristics; else if (strcmp(optarg, "uncoordinated_heuristics") == 0) decision_f = uncoordinated_heuristics; else if (strcmp(optarg, "step_heuristics") == 0) decision_f = step_heuristics; else if (strcmp(optarg, "core_controller") == 0) decision_f = core_controller; else if (strcmp(optarg, "machine_state_controller") == 0) decision_f = machine_state_controller; else { fprintf(stderr, "%s: unknown decision function\n", argv[0]); exit(1); } break; default: fprintf(stderr, "Usage: %s [-d decision_function]\n", argv[0]); exit(1); } argc -= optind; argv += optind; if (argc > 1) max_beats = argv[1]; /* setupping arbit */ heartbeat_dir = getenv("HEARTBEAT_ENABLED_DIR"); fail_if(heartbeat_dir == NULL, "environment variable HEARTBEAT_ENABLED_DIR undefined"); while (n_apps == 0) n_apps = get_heartbeat_apps(apps, sizeof(apps)/sizeof(apps[0])); fail_if(n_apps != 1, "this service only supports a single app. please delete c:\\system32"); printf("monitoring process %d\n", apps[0]); /* initrogenizing old river control structure */ core_count = get_core_count(); actuator_count = core_count + 3; controls = malloc(sizeof(actuator_t) * actuator_count); fail_if(!controls, "could not allocate actuators"); /* PROBLEM!!!!! the machine speed actuator needs to init last, but act first! WHAT NOW */ /* create the list in action order, but init in special order... QUICK AND DIRTY = OPTIMAL */ next_ctl = controls; *next_ctl++ = (actuator_t) { .id = ACTUATOR_MACHINE_SPD, .core = -1, .pid = apps[0], .init_f = machine_speed_init, .action_f = machine_speed_act }; for (i = 0; i < core_count; i++) *next_ctl++ = (actuator_t) { .id = ACTUATOR_SINGLE_FREQ, .core = i, .pid = -1, .init_f = single_freq_init, .action_f = single_freq_act }; *next_ctl++ = (actuator_t) { .id = ACTUATOR_GLOBAL_FREQ, .core = -1, .pid = -1, .init_f = global_freq_init, .action_f = global_freq_act }; *next_ctl++ = (actuator_t) { .id = ACTUATOR_CORE_COUNT, .core = -1, .pid = apps[0], .init_f = core_init, .action_f = core_act }; for (i = 1; i < actuator_count; i++) { err = controls[i].init_f(&controls[i]); fail_if(err, "cannot initialize actuator"); } /* initialize machine speed actuator last! */ err = controls[0].init_f(&controls[0]); fail_if(err, "cannot initialize actuator"); /* begin monitoration of lone protoss */ err = heart_rate_monitor_init(&hrm, apps[0]); fail_if(err, "cannot start heart rate monitor"); window_size = hrm_get_window_size(&hrm); current.beat = -1; do { do { err = hrm_get_current(&hrm, ¤t); } while (err || current.beat <= last_beat || current.window_rate == 0.0); last_beat = current.beat; if (current.beat < skip_until_beat) { print_status(¤t, skip_until_beat, '.', actuator_count, controls); continue; } /*printf("Current beat: %lld, tag: %d, window: %lld, window_rate: %f\n", current.beat, current.tag, window_size, current.window_rate);*/ decision_f(¤t, actuator_count, controls); acted = 0; for (i = 0; i < actuator_count; i++) { actuator_t *act = &controls[i]; if (act->set_value != act->value) { #if DEBUG printf("act %d: %d -> %d\n", i, act->value, act->set_value); #endif err = act->action_f(act); /* TODO: handle error */ if (err) fprintf(stderr, "action %d failed: %s\n", act->id, strerror(errno)); acted = 1; } } /* this is horrible but necessary */ controls[0].value = get_current_speed(&controls[0]); skip_until_beat = current.beat + (acted ? window_size : 1); print_status(¤t, skip_until_beat, acted ? '*' : '=', actuator_count, controls); } while (current.beat < max_beats); heart_rate_monitor_finish(&hrm); return 0; fail: return 1; } /* here are some globals without lexical scoping, just to mix things up! */ int actuator_count; actuator_t *controls;