static void reserve_state_check(struct work_struct *work)
{
struct otg_booting_delay *o_b_d = container_of(work,
struct otg_booting_delay, booting_work.work);
struct usb_notify *u_noti = container_of(o_b_d,
struct usb_notify, b_delay);
int enable = 1;
unsigned long state = 0;
state = u_noti->b_delay.reserve_state;
u_noti->o_notify->booting_delay_sec = 0;
pr_info("%s booting delay finished\n", __func__);
if (u_noti->b_delay.reserve_state != NOTIFY_EVENT_NONE) {
pr_info("%s event=%s(%lu) enable=%d\n", __func__,
event_string(state), state, enable);
if (check_event_type(state) & NOTIFY_EVENT_EXTRA)
blocking_notifier_call_chain
(&u_noti->o_notify->extra_notifier,
state, &enable);
else
atomic_notifier_call_chain
(&u_noti->o_notify->otg_notifier,
state, &enable);
}
}
void cli_event_error_str(cli_events_t *ctx, const char *str)
{
if (!ctx)
return;
cli_warnmsg("events: %s\n", str);
event_string(ctx, &ctx->errors, str);
}
static int otg_notifier_callback(struct notifier_block *nb,
unsigned long event, void *param)
{
struct otg_state_work *state_work;
pr_info("%s event=%s(%lu)\n", __func__,
event_string(event), event);
if (!u_notify) {
pr_err("u_notify is NULL\n");
return NOTIFY_DONE;
}
if (event > NOTIFY_EVENT_VBUSPOWER) {
pr_err("%s event is invalid\n", __func__);
return NOTIFY_DONE;
}
state_work = kmalloc(sizeof(struct otg_state_work), GFP_ATOMIC);
if (!state_work) {
pr_err("unable to allocate state_work\n");
return notifier_from_errno(-ENOMEM);
}
INIT_WORK(&state_work->otg_work, otg_notify_work);
state_work->event = event;
state_work->enable = *(int *)param;
queue_work(u_notify->notifier_wq, &state_work->otg_work);
return NOTIFY_OK;
}
void cli_event_string(cli_events_t *ctx, unsigned id, const char *str)
{
struct cli_event *ev = get_event(ctx, id);
if (!ev)
return;
if (ev->type != ev_string) {
cli_event_error_str(ctx, "cli_event_string must be called with ev_string type");
return;
}
event_string(ctx, ev, str);
}
int main(int argc, char *argv[])
{
int sock; /* Socket descriptor */
struct sockaddr_in echoServAddr; /* Echo server address */
unsigned short echoServPort = 5000; /* Echo server port */
char *servIP = "127.0.0.1"; /* Server IP address (dotted quad) */
char *echoString; /* String to send */
unsigned int echoStringLen; /* Length of string */
int loops;
int sleep_time;
if ((argc < 3) || (argc > 3)) /* Test for correct number of arguments */
{
fprintf(stderr, "Usage: %s <loops> <sleep_time_milis>\n",
argv[0]);
exit(1);
}
loops = atoi(argv[1]);
sleep_time = atoi(argv[2]);
/* Create a reliable, stream socket using TCP */
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) error("socket() failed");
/* Construct the server address structure */
memset(&echoServAddr, 0, sizeof(echoServAddr)); /* Zero out structure */
echoServAddr.sin_family = AF_INET; /* Internet address family */
echoServAddr.sin_addr.s_addr = inet_addr(servIP); /* Server IP address */
echoServAddr.sin_port = htons(echoServPort); /* Server port */
/* Establish the connection to the echo server */
if (connect(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0) error("connect() failed");
int avg = sleep_time;
int i;
for (i = 0; i < loops; i++) {
echoString = event_string();
echoStringLen = strlen(echoString); /* Determine input length */
if (send(sock, echoString, echoStringLen, 0) != echoStringLen) error("send() sent a different number of bytes than expected"); /* Send the string to the server */
avg += my_sleep(sleep_time);
avg = avg/2;
}
printf("%d:%d",avg, i);
printf("\n"); /* Print a final linefeed */
close(sock);
exit(0);
}
int read_event(int sfd)
{
uint8_t data[sizeof(struct l2tp_event) + 8];
struct l2tp_event *event = (struct l2tp_event *)&data[0];
bool done = false;
uint8_t *eptr = (uint8_t *)event;
int len, remaining = sizeof(*event);
/* Get header from client */
while (!done) {
len = recv(sfd, eptr, remaining, 0);
if (len < 0) {
if (errno == EINTR) {
continue;
} else {
break;
}
} else if (len == 0) {
return -ENOTCONN;
} else {
remaining -= len;
eptr += len;
if (!remaining)
done = true;
}
}
/* Get rest of message */
remaining = event->len;
done = false;
while (!done) {
len = recv(sfd, eptr, remaining, 0);
if (len < 0) {
if (errno == EINTR) {
continue;
} else {
break;
}
} else if (len == 0) {
return -ENOTCONN;
} else {
remaining -= len;
if (!remaining)
done = true;
}
}
fprintf(stdout, "Received %s event and %d bytes\n",
event_string(event->event),
event->len);
return EXIT_SUCCESS;
}
unsigned long get_cable_type(void)
{
unsigned long ret = 0;
if (!u_notify) {
ret = create_usb_notify();
if (ret) {
pr_err("unable create_usb_notify\n");
return -EFAULT;
}
}
pr_info("%s cable type =%s\n", __func__,
event_string(u_notify->c_type));
ret = u_notify->c_type;
return ret;
}
static int extra_notifier_callback(struct notifier_block *nb,
unsigned long event, void *param)
{
pr_info("%s event=%s(%lu)\n", __func__,
event_string(event), event);
if (!u_notify) {
pr_err("u_notify is NULL\n");
return NOTIFY_DONE;
}
if (event > NOTIFY_EVENT_VBUSPOWER) {
pr_err("%s event is invalid\n", __func__);
return NOTIFY_DONE;
}
extra_notify_state(event, *(int *)param);
return NOTIFY_OK;
}
void send_otg_notify(struct otg_notify *n,
unsigned long event, int enable)
{
int type = 0;
if (!n) {
pr_err("%s otg_notify is null\n", __func__);
return;
}
pr_info("%s event=%s(%lu) enable=%d\n", __func__,
event_string(event), event, enable);
type = check_event_type(event);
if (type & NOTIFY_EVENT_DELAY) {
if (n->booting_delay_sec) {
if (u_notify) {
u_notify->b_delay.reserve_state =
(enable) ? event : NOTIFY_EVENT_NONE;
pr_info("%s reserve event\n", __func__);
} else
pr_err("%s u_notify is null\n", __func__);
goto end;
}
}
if (type & NOTIFY_EVENT_EXTRA)
blocking_notifier_call_chain
(&n->extra_notifier, event, &enable);
else if (type & NOTIFY_EVENT_STATE)
atomic_notifier_call_chain
(&n->otg_notifier, event, &enable);
else
goto end;
end:
return;
}
void record_event(EventCode code, Sprite *by, Background *floor,
Sprite *subject, boolean type_of_subject_fixed,
int key, AddToWorkingSet add_to_working_set,
boolean notebook_page_really_selected,
int label_index
#if TT_POST3187
,Sprite *original_subject
#endif
) {
#if TT_DEBUG_ON
if (tt_debug_mode == 5050) {
tt_error_file() << timeGetTime() << " ";
Event *event = new Event(code,NULL);
event->debug(NULL);
delete event;
};
#endif
// until I generate instructions programmer actions aren't recorded
if (tt_log_version_number >= 22) {
if (by == NULL || tt_recording_off || (by->kind_of() != ROBOT && by->kind_of() != ROBOT_IN_TRAINING) || tt_shutting_down) return;
} else {
if (by == NULL || tt_recording_off || by->kind_of() == PROGRAMMER || tt_shutting_down) return;
};
// third condition prior to 050400 was by->kind_of() == PROGRAMMER but by might be a bird for example
boolean body_cubby;
if (by->kind_of() == ROBOT) {
body_cubby = (subject == ((Robot *) by)->pointer_to_working_cubby());
} else if (floor != NULL || tt_log_version_number < 22) { // condition added 050400
body_cubby = (subject == floor->pointer_to_body_cubby());
} else {
body_cubby = FALSE;
};
// doesn't count that its main cubby if put somewhere
// if (body_cubby) {
// body_cubby = (subject->pointer_to_leader() == NULL ||
// subject->pointer_to_leader()->kind_of() == ROBOT_IN_TRAINING);
// };
const boolean notebook = (tt_toolbox != NULL && subject == tt_toolbox_notebook);
// following screws up if main cubby put into something and then taken out
// also bad to have just 1 optimization like this
// restored for notebook since it is shared and shouldn't be moved by robots
if (code == RELEASE_ITEM && notebook) {
// ((body_cubby && subject->pointer_to_leader() == NULL) || notebook)) {
// could be more clever and if anything is released right
// after being picked up it is ignored
// picked up and released main cubby or notebook
// (or vacuumed up and restored)
// robot shouldn't be doing this so ok to assume floor
if (tt_events != NULL) {
Event *last_event = tt_events->last()->first();
if (last_event->event_code() == GRASP_ITEM || last_event->event_code() == VACUUM_APPLY) {
// test new on 120305 since can be keyboard event, for example
floor->remove_last_n_events(1); // must have been a grasp_item (or apply_vacuum)
return;
};
}; // else should be OK since there are no events to remove, right?
};
if (code == RELEASE_ITEM_ON && by->kind_of() == ROBOT_IN_TRAINING) {
if (subject->kind_of() == NEST && subject->infinite_stack()) {
// returning a nest with egg back to stack but already
// generated a hatch_bird message
floor->remove_last_n_events(1);
((Robot *) by)->remove_last_working_set_item();
// taken care of by :now_part_of_somthing()
// } else { // Happens in event.cpp so needs to happen here as well
// ((Robot *) by)->remove_tool_from_working_set(subject);
};
};
Path *path = NULL;
Event *new_item_event = NULL;
if (body_cubby || notebook) {
add_to_working_set = DONT_ADD_TO_WORKING_SET;
};
if (code == NEW_ITEM || code == HATCH_BIRD ||
code == RELEASE_ITEM || code == VACUUM_APPLY_RESTORE) {
if (subject != NULL && !body_cubby &&
!(tt_toolbox != NULL && toolbox_tool(subject))) {
// either defining a body so add to this
// or by is a robot so add to its
// or by is programmer so ignore
switch (by->kind_of()) {
case ROBOT_IN_TRAINING:
// if (!by->still_running()) {
if (add_to_working_set != DONT_ADD_TO_WORKING_SET) {
int index = ((Robot *) by)->add_to_working_set(subject,(add_to_working_set == ADD_TO_WORKING_SET_IF_NEW));
if (type_of_subject_fixed) {
path = new Path(index,new Path(subject->fine_kind_of()));
} else if (code == VACUUM_APPLY_RESTORE) {
path = new Path(index,new Path(NONE_GIVEN));
subject = NULL;
};
// } else if (code == HATCH_BIRD) {
// path = new Path(index,new Path(BIRD));
// } else {
// path = new Path(index,new Path(NONE_GIVEN));
};
break;
// }; // otherwise fall thru to the following
case ROBOT:
if (add_to_working_set != DONT_ADD_TO_WORKING_SET) {
((Robot *) by)->add_to_working_set(subject,(add_to_working_set == ADD_TO_WORKING_SET_IF_NEW));
};
break;
};
// floor->add_to_some_working_set(subject,by);
if (code != GRASP_ITEM && code != GRASP_NEST && code != VACUUM_APPLY_RESTORE &&
notebook_page_really_selected) {
subject->set_available_for_indexing(TRUE);
};
};
// following commented out so path is recorded for generating Java properly
// if (code == VACUUM_APPLY_RESTORE) subject = NULL;
if (path != NULL) {
new_item_event = new Event(NEW_ITEM,path,0);
if (code != VACUUM_APPLY_RESTORE) {
if (tt_events == NULL) {
tt_events = new Events(new_item_event,tt_events);
} else {
tt_events->insert_at_end(new_item_event);
};
new_item_event = NULL;
}; // else add it after this event
};
// following just are used to update working set
// can combine them to one?? except for descriptions?
if (code == NEW_ITEM || code == HATCH_BIRD) return;
};
if (by->kind_of() != ROBOT_IN_TRAINING) {
if (code == NEW_MAIN_CUBBY) {
floor->set_body_cubby((Cubby *) subject, by);
};
return; // already knows the path
};
if (subject != NULL && code == GRASP_ITEM) {
if (subject->kind_of() == NEST) {
code = GRASP_NEST; // the whole thing not the top of its stack
} else if (tt_toolbox != NULL) {
// used to do switch (subject->kind_of()) but copies of tools break
if (subject == tt_toolbox_copier) {
code = GRASP_COPIER;
} else if (subject == tt_toolbox_vacuum) {
code = GRASP_VACUUM;
} else if (subject == tt_toolbox_expander) {
code = GRASP_EXPANDER;
} else if (subject == tt_toolbox) {
return; // no semantic meaning
};
} else { // e.g. puzzle game
switch (subject->kind_of()) {
case COPIER:
code = GRASP_COPIER;
break;
case VACUUM:
code = GRASP_VACUUM;
break;
case EXPANDER:
code = GRASP_EXPANDER;
break;
};
};
};
if (subject != NULL && subject->kind_of() == NEST) {
// don't wait for subject to receieve something to apply tool
switch (code) {
case COPIER_APPLY:
code = COPIER_APPLY_NEST;
break;
case VACUUM_APPLY:
code = VACUUM_APPLY_NEST;
break;
case APPLY_GRASPED_ITEM:
code = APPLY_GRASPED_NEST;
break;
};
};
if (subject != NULL && code == RELEASE_ITEM) {
subject->set_available_for_indexing(TRUE);
// switch (subject->kind_of()) {
if (tt_toolbox != NULL) {
if (subject == tt_toolbox_copier) {
code = RELEASE_COPIER;
} else if (subject == tt_toolbox_vacuum) {
code = RELEASE_VACUUM;
} else if (subject == tt_toolbox_expander) {
code = RELEASE_EXPANDER;
} else if (subject == tt_toolbox) { // was subject == tt_toolbox_expander ||
return;
};
} else { // puzzle game
switch (subject->kind_of()) {
case COPIER:
code = RELEASE_COPIER;
break;
case VACUUM:
code = RELEASE_VACUUM;
break;
case EXPANDER:
code = RELEASE_EXPANDER;
break;
};
};
};
// safe cast?
path = ((Floor *) floor)->compute_path(subject,code,(Robot *) by,notebook_page_really_selected
#if TT_POST3187
,original_subject
#endif
);
#if TT_CAREFUL
if (path == NULL && subject != tt_toolbox) { // ignore actions on Toolbox...
#if TT_DEBUG_ON
#if TT_NEW_IO
output_string_stream err_message;
#else
string buffer = new char[10000];
output_string_stream err_message(buffer,10000);
#endif
err_message << "Warning: Robot is confused and couldn't find ";
subject->describe(err_message,INDEFINITE_ARTICLE);
err_message << ".";
err_message.put('\0');
say_error(err_message.STR,TRUE);
#if !TT_NEW_IO
delete [] buffer;
#endif
log(event_string(code));
#endif
return;
// working_set->insert_at_end_if_not_member(subject);
// path = compute_path(subject);
};
#endif
// if (code == RELEASE_ITEM_ON && by->kind_of() == ROBOT_IN_TRAINING &&
// subject->kind_of() != PROGRAM_PAD && subject->is_container()) { // notebooks use this as well as cubbies
//// && subject->pointer_to_leader() != NULL) {
// // is now part of something and should be accessed via that container
// ((Robot *) by)->remove_tool_from_working_set(subject);
// };
//on 5/27 re-wrote the above to match the similar situation in event.cpp
// handled by now_released_on
// if (code == RELEASE_ITEM_ON && by->kind_of() == ROBOT_IN_TRAINING &&
// // except when dropping a cubby on a number since both are around afterwards
// !(item_underneath != NULL && item_underneath->kind_of() == INTEGER &&
// subject->kind_of() == CUBBY)) {
// ((Robot *) by)->remove_tool_from_working_set(subject);
// };
if (code == LABEL_CHARACTER) {
path->add_to_end(new Path(label_index));
};
if (code == NEW_MAIN_CUBBY) { // do this after computing the path
floor->set_body_cubby((Cubby *) subject, by);
};
if ((code == GRASP_ITEM || code == GRASP_NEST) && !notebook_page_really_selected) {
subject->set_available_for_indexing(FALSE); // does this ever get restored??
};
Event *event = new Event(code,path,key);
if (tt_events == NULL) {
tt_events = new Events(event,tt_events);
} else {
tt_events->insert_at_end(event);
};
if (new_item_event != NULL) {
tt_events->insert_at_end(new_item_event);
};
if (by->kind_of() == ROBOT_IN_TRAINING &&
code != SELECT_STACK_ITEM) {
if (subject != ((Robot *) by)->pointer_to_initial_tool()) {
((Robot *) by)->decrement_training_counter();
};
};
};
static void extra_notify_state(unsigned long event, int enable)
{
struct otg_notify *notify = NULL;
if (!u_notify) {
pr_err("u_notify is NULL\n");
goto err;
}
pr_info("%s+ event=%s(%lu), enable=%s\n", __func__,
event_string(event), event, enable == 0 ? "off" : "on");
notify = get_otg_notify();
switch (event) {
case NOTIFY_EVENT_NONE:
break;
case NOTIFY_EVENT_OVERCURRENT:
if (!u_notify->ndev.dev) {
pr_err("ndev is NULL. Maybe usb host is not supported.\n");
break;
}
host_state_notify(&u_notify->ndev,
NOTIFY_HOST_OVERCURRENT);
pr_err("OTG overcurrent!!!!!!\n");
break;
case NOTIFY_EVENT_VBUSPOWER:
if (enable)
u_notify->ndev.booster = NOTIFY_POWER_ON;
else
u_notify->ndev.booster = NOTIFY_POWER_OFF;
break;
case NOTIFY_EVENT_SMSC_OVC:
if (enable)
ovc_start(u_notify);
else
ovc_stop(u_notify);
break;
case NOTIFY_EVENT_SMTD_EXT_CURRENT:
if (u_notify->c_type != NOTIFY_EVENT_SMARTDOCK_TA) {
pr_err("No smart dock!!!!!!\n");
break;
}
if (notify->set_battcall)
notify->set_battcall
(NOTIFY_EVENT_SMTD_EXT_CURRENT, enable);
break;
case NOTIFY_EVENT_MMD_EXT_CURRENT:
if (u_notify->c_type != NOTIFY_EVENT_MMDOCK) {
pr_err("No mmdock!!!!!!\n");
break;
}
if (notify->set_battcall)
notify->set_battcall
(NOTIFY_EVENT_MMD_EXT_CURRENT, enable);
break;
default:
break;
}
pr_info("%s- event=%s(%lu), cable=%s\n", __func__,
event_string(event), event,
event_string(u_notify->c_type));
err:
return;
}
static void otg_notify_state(unsigned long event, int enable)
{
struct otg_notify *notify = NULL;
if (!u_notify) {
pr_err("u_notify is NULL\n");
goto no_save_event;
}
pr_info("%s+ event=%s(%lu), enable=%s\n", __func__,
event_string(event), event, enable == 0 ? "off" : "on");
notify = get_otg_notify();
switch (event) {
case NOTIFY_EVENT_NONE:
break;
case NOTIFY_EVENT_SMARTDOCK_USB:
case NOTIFY_EVENT_VBUS:
if (enable) {
u_notify->ndev.mode = NOTIFY_PERIPHERAL_MODE;
if (notify->is_wakelock)
wake_lock(&u_notify->wlock);
if (gpio_is_valid(notify->redriver_en_gpio))
gpio_direction_output
(notify->redriver_en_gpio, 1);
if (notify->set_peripheral)
notify->set_peripheral(true);
} else {
u_notify->ndev.mode = NOTIFY_NONE_MODE;
if (notify->set_peripheral)
notify->set_peripheral(false);
if (gpio_is_valid(notify->redriver_en_gpio))
gpio_direction_output
(notify->redriver_en_gpio, 0);
if (notify->is_wakelock)
wake_unlock(&u_notify->wlock);
}
break;
case NOTIFY_EVENT_LANHUB_TA:
u_notify->diable_v_drive = enable;
if (enable)
u_notify->oc_noti = 0;
if (notify->set_lanhubta)
notify->set_lanhubta(enable);
break;
case NOTIFY_EVENT_LANHUB:
if (notify->unsupport_host) {
pr_err("This model doesn't support usb host\n");
goto err;
}
u_notify->diable_v_drive = enable;
if (enable) {
u_notify->oc_noti = 0;
u_notify->ndev.mode = NOTIFY_HOST_MODE;
if (notify->is_wakelock)
wake_lock(&u_notify->wlock);
host_state_notify(&u_notify->ndev, NOTIFY_HOST_ADD);
if (gpio_is_valid(notify->redriver_en_gpio))
gpio_direction_output
(notify->redriver_en_gpio, 1);
if (notify->set_host)
notify->set_host(true);
} else {
u_notify->ndev.mode = NOTIFY_NONE_MODE;
if (notify->set_host)
notify->set_host(false);
if (gpio_is_valid(notify->redriver_en_gpio))
gpio_direction_output
(notify->redriver_en_gpio, 0);
host_state_notify(&u_notify->ndev, NOTIFY_HOST_REMOVE);
if (notify->is_wakelock)
wake_unlock(&u_notify->wlock);
}
break;
case NOTIFY_EVENT_HOST:
if (notify->unsupport_host) {
pr_err("This model doesn't support usb host\n");
goto err;
}
u_notify->diable_v_drive = 0;
if (enable) {
u_notify->ndev.mode = NOTIFY_HOST_MODE;
if (notify->is_wakelock)
wake_lock(&u_notify->wlock);
host_state_notify(&u_notify->ndev, NOTIFY_HOST_ADD);
if (gpio_is_valid(notify->redriver_en_gpio))
gpio_direction_output
(notify->redriver_en_gpio, 1);
if (notify->auto_drive_vbus) {
u_notify->oc_noti = 1;
if (notify->vbus_drive)
notify->vbus_drive(1);
}
if (notify->set_host)
notify->set_host(true);
} else {
u_notify->ndev.mode = NOTIFY_NONE_MODE;
if (notify->auto_drive_vbus) {
u_notify->oc_noti = 0;
if (notify->vbus_drive)
notify->vbus_drive(0);
}
if (notify->set_host)
notify->set_host(false);
if (gpio_is_valid(notify->redriver_en_gpio))
gpio_direction_output
(notify->redriver_en_gpio, 0);
host_state_notify(&u_notify->ndev, NOTIFY_HOST_REMOVE);
if (notify->is_wakelock)
wake_unlock(&u_notify->wlock);
}
break;
case NOTIFY_EVENT_CHARGER:
if (notify->set_charger)
notify->set_charger(enable);
break;
case NOTIFY_EVENT_MMDOCK:
enable_ovc(u_notify, enable);
/* To detect overcurrent, ndev state is initialized */
if (enable)
host_state_notify(&u_notify->ndev,
NOTIFY_HOST_NONE);
case NOTIFY_EVENT_SMARTDOCK_TA:
case NOTIFY_EVENT_AUDIODOCK:
if (notify->unsupport_host) {
pr_err("This model doesn't support usb host\n");
goto err;
}
u_notify->diable_v_drive = enable;
if (enable) {
u_notify->ndev.mode = NOTIFY_HOST_MODE;
if (notify->is_wakelock)
wake_lock(&u_notify->wlock);
if (notify->set_host)
notify->set_host(true);
} else {
u_notify->ndev.mode = NOTIFY_NONE_MODE;
if (notify->set_host)
notify->set_host(false);
if (notify->is_wakelock)
wake_unlock(&u_notify->wlock);
}
break;
case NOTIFY_EVENT_DRIVE_VBUS:
if (notify->unsupport_host) {
pr_err("This model doesn't support usb host\n");
goto no_save_event;
}
if (u_notify->diable_v_drive) {
pr_info("cable type=%s disable vbus draw\n",
event_string(u_notify->c_type));
goto no_save_event;
}
u_notify->oc_noti = enable;
if (notify->vbus_drive)
notify->vbus_drive((bool)enable);
goto no_save_event;
default:
break;
}
err:
if (enable)
u_notify->c_type = event;
else
u_notify->c_type = NOTIFY_EVENT_NONE;
no_save_event:
pr_info("%s- event=%s, cable=%s\n", __func__,
event_string(event),
event_string(u_notify->c_type));
}
void run_gp(multipop *mpop, int startgen, event *t_eval, event *t_breed,
int startfromcheckpoint) {
char *param;
int gen;
int maxgen;
int exch_gen;
int i, j;
int checkinterval;
char *checkfileformat;
char *checkfilename = NULL;
event start, end, diff;
int term = 0;
termination_override =0;
int stt_interval;
int bestn;
if (!startfromcheckpoint) {
/* get the number of top individuals to track. */
bestn = atoi(get_parameter("output.bestn"));
if (bestn < 1) {
error( E_WARNING,
"\"output.bestn\" must be at least 1. defaulting to 1.");
bestn = 1;
}
/* allocate statistics for overall run. */
run_stats = (popstats *) MALLOC((mpop->size + 1) * sizeof(popstats));
for (i = 0; i < mpop->size + 1; ++i) {
run_stats[i].bestn = bestn;
run_stats[i].size = -1;
}
/* initialize the linked list of saved individuals. */
saved_head = (saved_ind *) MALLOC(sizeof(saved_ind));
saved_head->ind = NULL;
saved_head->refcount = 0;
saved_head->next = NULL;
saved_tail = saved_head;
}
/* get the maximum number of generations. */
param = get_parameter("max_generations");
if (param == NULL)
error( E_FATAL_ERROR, "no value specified for \"max_generations\".");
maxgen = atoi(param);
if (maxgen <= 0)
error( E_FATAL_ERROR, "\"max_generations\" must be greater than zero.");
/* get the interval for subpopulation exchanges, if there is more than
one subpopulation. */
if (mpop->size > 1) {
param = get_parameter("multiple.exch_gen");
if (param == NULL)
error( E_FATAL_ERROR,
"no value specified for \"multiple.exch_gen\".");
exch_gen = atoi(param);
if (exch_gen <= 0)
error( E_FATAL_ERROR,
"\"multiple.exch_gen\" must be greater than zero.");
}
/* get the interval for doing checkpointing. */
param = get_parameter("checkpoint.interval");
if (param == NULL)
/* checkpointing disabled. */
checkinterval = -1;
else
checkinterval = atoi(param);
/* get the format string for the checkpoint filenames. */
checkfileformat = get_parameter("checkpoint.filename");
checkfilename = (char *) MALLOC(strlen(checkfileformat) + 50);
/* get the interval for writing information to the .stt file. */
stt_interval = atoi(get_parameter("output.stt_interval"));
if (stt_interval < 1)
error( E_FATAL_ERROR,
"\"output.stt_interval\" must be greater than zero.");
oputs( OUT_SYS, 10, "\n\nstarting evolution.\n");
/* print out how often we'll be doing checkpointing. */
if (checkinterval > 0)
oprintf( OUT_SYS, 20,
"checkpointing will be done every %d generations and "
"after the last generation.\n", checkinterval);
else if (checkinterval == 0)
oprintf( OUT_SYS, 20, "checkpointing will be done only after the last "
"generation.\n");
else
oprintf( OUT_SYS, 20, "no checkpointing will be done.\n");
/* the big loop. */
for (gen = startgen; gen < maxgen && !term; ++gen) {
oprintf( OUT_SYS, 20, "=== generation %d.\n", gen);
generation_No = gen;
/* unless this is the first generation after loading a checkpoint
file... */
if (!(startfromcheckpoint && gen == startgen)) {
/* evaluate the population. */
event_mark(&start);
for (i = 0; i < mpop->size; ++i) { //generation_No = i;
evaluate_pop(mpop->pop[i]);
}
event_mark(&end);
event_diff(&diff, &start, &end);
#ifdef TIMING_AVAILABLE
oprintf( OUT_SYS, 40, " evaluation complete. (%s)\n",
event_string(&diff));
#else
oprintf ( OUT_SYS, 40, " evaluation complete.\n" );
#endif
event_accum(t_eval, &diff);
/* calculate and print statistics. returns 1 if user termination
criterion was met, 0 otherwise. */
term = generation_information(gen, mpop, stt_interval,
run_stats[0].bestn);
if (term) {
//oprintf( OUT_SYS, 30, "user termination criterion met.\n");
/*extern float *optimal_in_generation;
extern int *optimal_index_in_generation;
extern int same_optimal_count;
int i;
for (i = 0; i < generationSIZE; i++) {
if ((int) optimal_in_generation[i] == -1) {
printf("tried to Break");
break;
}
printf("Index: %d ERR : %f -Index %d Same : %i\n", i,
optimal_in_generation[i],
optimal_index_in_generation[i], same_optimal_count);
}*/
}
flush_output_streams();
}
/** write a checkpoint file if checkinterval is non-negative and:
we've reached the last generation, or
the user termination criterion has been met, or
we've reached the specified checkpoint interval. **/
if (checkinterval >= 0
&& (gen == maxgen || term
|| (checkinterval > 0 && gen > startgen
&& (gen % checkinterval) == 0))) {
sprintf(checkfilename, checkfileformat, gen);
write_checkpoint(gen, mpop, checkfilename);
}
/** if this is not the last generation and the user criterion hasn't
been met, then do breeding. **/
if (gen != maxgen && !term) {
/** exchange subpops if it's time. **/
if (mpop->size > 1 && gen && (gen % exch_gen) == 0) {
exchange_subpopulations(mpop);
oprintf( OUT_SYS, 10, " subpopulation exchange complete.\n");
}
/* breed the new population. */
event_mark(&start);
for (i = 0; i < mpop->size; ++i)
mpop->pop[i] = change_population(mpop->pop[i], mpop->bpt[i]);
event_mark(&end);
event_diff(&diff, &start, &end);
/* call the application end-of-breeding callback. */
app_end_of_breeding(gen, mpop);
#ifdef TIMING_AVAILABLE
oprintf( OUT_SYS, 30, " breeding complete. (%s)\n",
event_string(&diff));
#else
oprintf ( OUT_SYS, 30, " breeding complete.\n" );
#endif
event_accum(t_breed, &diff);
}
/* free unused ERCs. */
ephem_const_gc();
flush_output_streams();
}
/** free up a lot of stuff before returning. */
if (checkfilename)
FREE(checkfilename);
ephem_const_gc();
for (i = 0; i < mpop->size + 1; ++i) {
for (j = 0; j < run_stats[i].bestn; ++j)
--run_stats[i].best[j]->refcount;
FREE(run_stats[i].best);
}
FREE(run_stats);
saved_individual_gc();
FREE(saved_head);
}