static void set_md_dul_throttle(int level) // level 1~10, 1: unlimit for 1s and zero for 9s, ..., 10: unlimit
{
TM_DBG_LOG("set_md_dul_throttle %d\n", level);
if (level >=1 && level < 10)
{
level_timeout = level;
reset_timers();
}
else if (level == 10)
{
set_md_ul_throttle(-1);
stop_timers();
}
else
TM_INFO_LOG("invalid level %d, ignored\n", level);
// if 10 set unlimit and stop timer
// if timer not created, create timer
// if timer created, reset timer
// unlimit ul, and start timer for level s
// when times out, limit ul to 1kbps, and start timer for 10 - level s
}
static void set_term(struct server_context_t *s, uint64_t term) {
if(s->state == LEADER) {
//if currently is leader and stepping down to follower
//then remove heartbeat timer and add election timer
reset_timers(s, true, false);
}
s->current_term = term;
s->state = FOLLOWER;
}
void reset(void)
{
NGPGfx->power();
Z80_reset();
reset_int();
reset_timers();
reset_memory();
BIOSHLE_Reset();
reset_registers(); // TLCS900H registers
reset_dma();
}
static void request_vote_cb(struct data_t *result, char *err, void *data) {
struct server_context_t *s = (struct server_context_t *)data;
if(err) {
//what should we do with bysentine errors?
//LOG: fatal error. TODO: exit?
return;
}
if(s->state != CANDIDATE) {
return;
}
struct request_vote_output_t *vote = get_request_vote_output(result);
if(!vote) {
log_fatal_and_exit(s,
"RequestVoteCallback: Response parsing failed");
return;
}
int pair_vote = vote->vote_granted;
uint64_t pair_term = vote->term;
free(vote);
if(pair_vote && pair_term == s->current_term
&& s->state == CANDIDATE) {
s->current_votes++;
} else {
if(pair_term > s->current_term) {
set_term(s, pair_term);
s->voted_for = 0;
save_state(s);
}
return;
}
int votes_needed = s->quoram_size/2 + 1;
if(s->current_votes == votes_needed) {
s->state = LEADER;
s->current_leader = s->id;
DBG_LOG(LOG_INFO, "[%s][%d] Server is elected as the leader", ss[s->state], s->current_term);
save_state(s);
//reset timer such that election timeout does not occur
//and heartbeat timeout occurs
reset_timers(s, false, true);
for(int i = 0; i < s->quoram_size - 1; i++) {
if(s->last_entry) {
s->next_index[i] = s->last_entry->index + 1;
} else {
s->next_index[i] = 1;
}
s->match_index[i] = 0;
}
send_heartbeat(s);
}
}
__LINK_C error_t timer_post_task_prio(task_t task, timer_tick_t fire_time, uint8_t priority)
{
error_t status = ENOMEM;
if(priority > MIN_PRIORITY)
return EINVAL;
start_atomic();
uint32_t empty_index = FRAMEWORK_TIMER_STACK_SIZE;
for(uint32_t i = 0; i < FRAMEWORK_TIMER_STACK_SIZE; i++)
{
if(NG(timers)[i].f == 0x0 && empty_index == FRAMEWORK_TIMER_STACK_SIZE)
{
empty_index = i;
}
else if(NG(timers)[i].f == task)
{
//for now: do not allow an event to be scheduled more than once
//otherwise we risk having the same task being scheduled twice and only executed once
//because the scheduler disallows the same task to be scheduled multiple times
status = EALREADY;
break;
}
}
if(status != EALREADY && empty_index != FRAMEWORK_TIMER_STACK_SIZE)
{
bool timers_reset = reset_timers();
NG(timers)[empty_index].f = task;
NG(timers)[empty_index].next_event = fire_time;
NG(timers)[empty_index].priority = priority;
//if there is no event scheduled, this event will run before the next scheduled event
//or we reset the timers: trigger a reconfiguration of the next scheduled event
bool do_config = NG(next_event) == NO_EVENT || timers_reset;
if(!do_config)
{
uint32_t counter = timer_get_counter_value();
//if the new event should fire sooner than the old event --> trigger reconfig
//this is done using signed ints (compared to the current counter)
//to ensure propper handling of timer overflows
int32_t next_fire_delay = ((int32_t)fire_time) - ((int32_t)counter);
int32_t old_fire_delay = ((int32_t)NG(timers)[NG(next_event)].next_event) - ((int32_t)counter);
do_config = next_fire_delay < old_fire_delay;
}
if(do_config)
configure_next_event();
status = SUCCESS;
}
end_atomic();
return status;
}
static uint32_t get_next_event()
{
//this function should only be called from an atomic context
reset_timers();
int32_t min_delay;
uint32_t next_fire_event = NO_EVENT;
uint32_t counter = timer_get_counter_value();
for(uint32_t i = 0; i < FRAMEWORK_TIMER_STACK_SIZE; i++)
{
if(NG(timers)[i].f == 0x0)
continue;
//trick borrowed from AODV: by using signed integers in this way
//we know that if the event has already passed delay_ticks will be < 0
// --> events are sorted from past -> future regardless of any (pending) overflows
int32_t delay_ticks = ((int32_t)NG(timers)[i].next_event) - ((int32_t)counter);
if(next_fire_event == NO_EVENT || delay_ticks < min_delay)
{
min_delay = delay_ticks;
next_fire_event = i;
}
}
return next_fire_event;
}
static void election_timeout_callback(int fd, short event, void *arg) {
struct server_context_t *s = (struct server_context_t *)arg;
if(event & EV_TIMEOUT) {
DBG_LOG(LOG_INFO, "[%s][%d] election timeout occurred", ss[s->state], s->current_term);
//election timeout occurred -- do the candidate activities
s->state = CANDIDATE;
s->current_leader = -1;
s->voted_for = s->id;
s->current_term++;
save_state(s);
s->current_votes = 1;
//reset the previous election timer and add new one such that
//if split vote occurs we have one more election
reset_timers(s, true, false);
//check if quoram_size already equal to required majoriy
int votes_needed = s->quoram_size/2 + 1;
if(votes_needed == s->current_votes) {
s->state = LEADER;
s->current_leader = s->id;
save_state(s);
} else {
//send RequestVote RPC to pairs
struct request_vote_input_t *input = (struct request_vote_input_t *)
malloc(sizeof(struct request_vote_input_t));
if(!input) {
set_term(s, s->current_term - 1);
return;
}
input->term = s->current_term;
input->candidate_id = s->id;
if(s->last_entry) {
input->last_log_index = s->last_entry->index;
input->last_log_term = s->last_entry->term;
} else {
input->last_log_index = 0;
input->last_log_term = 0;
}
struct method_t *rpc = make_request_vote_rpc_method(input);
if(!rpc) {
free(input);
set_term(s, s->current_term - 1);
return;
}
for(int i = 0; i < s->quoram_size - 1; i++) {
if(rpc_call(s->rpc_c, s->peers[i]->dest,
rpc, request_vote_cb, s)) {
//just log warning, as peers might go down
DBG_LOG(LOG_WARN, "[%s][%d] RPC call failed for peer %d",
ss[s->state], s->current_term, s->peers[i]->id);
}
}
free(input);
free_method_t(rpc);
} //end else-if
}
}
struct data_t *handle_append_entries(struct data_t *params[], int nparams, char **err, void *data) {
struct server_context_t *s = (struct server_context_t *)data;
struct append_entries_input_t *input = get_append_entries_input_params(params, nparams);
if(!input) {
*err = u_strdup("error while parsing input parameters");
log_fatal_and_exit(s,
"AppendEntries: Error while parsing input parameters");
return NULL;
}
int is_fatal = 0;
//append entries logic
struct append_entries_output_t output = { 0, 0 };
if(input->term < s->current_term) {
//leader has older term hence reject request
output.term = s->current_term;
output.success = 0;
} else {
//reset the election timeout; no point in adding heartbeat timer since
//this is follower
reset_timers(s, true, false);
int should_save_state = 0;
if(s->current_term < input->term) {
set_term(s, input->term);
should_save_state = 1;
}
//else if(s->state != FOLLOWER) {
// s->state = FOLLOWER;
//}
if(s->current_leader != input->leader_id) {
s->current_leader = input->leader_id;
should_save_state = 1;
DBG_LOG(LOG_INFO, "[%s][%d] new leader = %d",
ss[s->state], s->current_term, s->current_leader);
}
if(should_save_state) {
save_state(s);
}
if(!s->last_entry) {
if(input->prev_log_index == 0) {
if(input->nentries > 0) {
struct log_entry_t *last =
append_log_entries(s->log, input->entries, input->nentries);
if(!last) {
is_fatal = 1;
*err = u_strdup("memory allocation failed");
log_fatal_and_exit(s, "AppendEntries: Memory allocation failed");
goto fatal_exit;
}
s->last_entry = last;
}
output.term = s->current_term;
output.success = 1;
} else {
//wait until leader readjusts its match-index
//to point to 0
DBG_LOG(LOG_INFO, "[%s][%d] index readjustment %llu -> 0",
ss[s->state], s->current_term, input->prev_log_index);
output.term = s->current_term;
output.success = 0;
}
} else {
if(s->last_entry->index < input->prev_log_index) {
//wait until leader readjusts its match-index
//to point to last entries index
output.term = s->current_term;
output.success = 0;
DBG_LOG(LOG_INFO, "[%s][%d] index readjustment %llu -> %llu",
ss[s->state], s->current_term, input->prev_log_index,
s->last_entry->index);
} else {
uint64_t i = s->last_entry->index;
struct log_entry_t *le = s->last_entry;
for(;;) {
if(le->index == input->prev_log_index) {
if(le->term != input->prev_log_term) {
//prev_log_term didnt match with
//corresponding index (§5.3)
output.term = s->current_term;
output.success = 0;
DBG_LOG(LOG_INFO, "[%s][%d] term readjustment %llu -> %llu at index = %llu",
ss[s->state], s->current_term,
input->prev_log_term, le->term, le->index);
} else {
if(input->nentries > 0) {
//delete entries after prev_log_term
//and append new entries to match entries
//to the server log (§5.3)
struct log_entry_t *last =
append_log_entries(s->log,
input->entries, input->nentries);
if(!last) {
is_fatal = 1;
*err = u_strdup("memory allocation failed");
log_fatal_and_exit(s,
"AppendEntries: Memory allocation failed");
goto fatal_exit;
}
s->last_entry = last;
}
output.term = s->current_term;
output.success = 1;
}
break;
}
i--;
if(i > 0) {
le = get_log_entry_at(s->log, i);
} else {
break;
}
}
if(i == 0) {
//LOG: fatal and impossible scenario where there are some
//entries present but the index never coverages to server's
is_fatal = 1;
*err = u_strdup("raft invarient failed");
log_fatal_and_exit(s, "AppendEntries: Raft invarient failed");
goto fatal_exit;
}
}
}
}
commit_unapplied_entries(s, input->leader_commit_index);
fatal_exit:
if(!output.success && input->nentries) {
//XXX: this is memory leak
//for(int i = 0; i < input->nentries; i++) {
// free(input->entries[i]->buffer);
// free(input->entries[i]);
//}
free(input->entries);
}
free(input);
if(is_fatal) {
return NULL;
} else {
return make_append_entries_rpc_response(&output);
}
}
Task* make_task (Bool is_boot, Heapcleaner_Args* cleaner_args) {
// =========
//
// This function is called two places, one each in:
//
// src/c/heapcleaner/import-heap.c
// src/c/main/load-compiledfiles.c
Task* task = NULL;
#if NEED_PTHREAD_SUPPORT
//
for (int i = 0; i < MAX_PTHREADS; i++) {
//
if (((pthread_table__global[i] = MALLOC_CHUNK(Pthread)) == NULL)
|| ((task = MALLOC_CHUNK(Task)) == NULL)
){
die ("runtime-state.c: unable to allocate pthread_table__global entry");
}
pthread_table__global[i]->task = task;
}
task = pthread_table__global[0]->task;
#else
if (((pthread_table__global[0] = MALLOC_CHUNK(Pthread)) == NULL)
|| ((task = MALLOC_CHUNK(Task)) == NULL)
){
die ("unable to allocate Lib7 state vector");
}
pthread_table__global[0]->task = task;
#endif
// Allocate and initialize the heap data structures:
//
set_up_heap( task, is_boot, cleaner_args ); // set_up_heap def in src/c/heapcleaner/heapcleaner-initialization.c
#if !NEED_PTHREAD_SUPPORT
//
set_up_pthread_state( pthread_table__global[ 0 ] );
#else
// 'set_up_heap' has created an agegroup0 buffer;
// partition it between our MAX_PTHREADS pthreads:
//
partition_agegroup0_buffer_between_pthreads( pthread_table__global ); // partition_agegroup0_buffer_between_pthreads def in src/c/heapcleaner/pthread-heapcleaner-stuff.c
// Initialize the per-Pthread Mythryl state:
//
for (int i = 0; i < MAX_PTHREADS; i++) {
//
set_up_pthread_state( pthread_table__global[i] );
// Single timers are currently shared
// among multiple pthreads:
//
if (i != 0) {
pthread_table__global[ i ] -> cpu_time_at_start_of_last_cleaning
= pthread_table__global[ 0 ] -> cpu_time_at_start_of_last_cleaning;
//
pthread_table__global[ i ] -> cumulative_cleaning_cpu_time
= pthread_table__global[ 0 ] -> cumulative_cleaning_cpu_time;
}
}
// Initialize the first Pthread here:
//
pthread_table__global[0]->pid = pth__get_pthread_id (); // pth__get_pthread_id def in src/c/pthread/pthread-on-posix-threads.c
// pth__get_pthread_id def in src/c/pthread/pthread-on-sgi.c
// pth__get_pthread_id def in src/c/pthread/pthread-on-solaris.c
pthread_table__global[0]->status = PTHREAD_IS_RUNNING;
#endif // NEED_PTHREAD_SUPPORT
// Initialize the timers:
//
reset_timers( pthread_table__global[0] ); // NEED_PTHREAD_SUPPORT note: For now, only Pthread 0 has timers.
return task;
} // fun make_task
void process_commands() {
unsigned long codenum; //throw away variable
if (code_seen('N')) {
gcode_N = code_value_long();
if (gcode_N != gcode_LastN+1 && (strstr(cmdbuffer, "M110") == NULL) ) {
gcode_LastN=0;
pc.printf("ok");
//if(gcode_N != gcode_LastN+1 && !code_seen("M110") ) { //Hmm, compile size is different between using this vs the line above even though it should be the same thing. Keeping old method.
//pc.printf("Serial Error: Line Number is not Last Line Number+1, Last Line:");
//pc.printf("%d\n",gcode_LastN);
//FlushSerialRequestResend();
return;
}
if (code_seen('*')) {
int checksum = 0;
int count=0;
while (cmdbuffer[count] != '*') checksum = checksum^cmdbuffer[count++];
if ( (int)code_value() != checksum) {
//pc.printf("Error: checksum mismatch, Last Line:");
//pc.printf("%d\n",gcode_LastN);
//FlushSerialRequestResend();
return;
}
//if no errors, continue parsing
} else {
//pc.printf("Error: No Checksum with line number, Last Line:");
//pc.printf("%d\n",gcode_LastN);
//FlushSerialRequestResend();
return;
}
gcode_LastN = gcode_N;
//if no errors, continue parsing
} else { // if we don't receive 'N' but still see '*'
if (code_seen('*')) {
//pc.printf("Error: No Line Number with checksum, Last Line:");
//pc.printf("%d\n",gcode_LastN);
return;
}
}
//continues parsing only if we don't receive any 'N' or '*' or no errors if we do. :)
if (code_seen('G')) {
switch ((int)code_value()) {
case 0: // G0 -> G1
case 1: // G1
reset_timers();//avoid timer overflow after 30 seconds
get_coordinates(); // For X Y Z E F
x_steps_to_take = abs(destination_x - current_x)*x_steps_per_unit;
y_steps_to_take = abs(destination_y - current_y)*y_steps_per_unit;
z_steps_to_take = abs(destination_z - current_z)*z_steps_per_unit;
e_steps_to_take = abs(destination_e - current_e)*e_steps_per_unit;
//printf(" x_steps_to_take:%d\n", x_steps_to_take);
time_for_move = max(X_TIME_FOR_MOVE,Y_TIME_FOR_MOVE);
time_for_move = max(time_for_move,Z_TIME_FOR_MOVE);
time_for_move = max(time_for_move,E_TIME_FOR_MOVE);
if (x_steps_to_take) x_interval = time_for_move/x_steps_to_take;
if (y_steps_to_take) y_interval = time_for_move/y_steps_to_take;
if (z_steps_to_take) z_interval = time_for_move/z_steps_to_take;
if (e_steps_to_take) e_interval = time_for_move/e_steps_to_take;
x_steps_remaining = x_steps_to_take;
y_steps_remaining = y_steps_to_take;
z_steps_remaining = z_steps_to_take;
e_steps_remaining = e_steps_to_take;
if (DEBUGGING) {
pc.printf("destination_x: %f\n",destination_x);
pc.printf("current_x: %f\n",current_x);
pc.printf("x_steps_to_take: %d\n",x_steps_to_take);
pc.printf("X_TIME_FOR_MOVE: %f\n",X_TIME_FOR_MOVE);
pc.printf("x_interval: %f\n\n",x_interval);
pc.printf("destination_y: %f\n",destination_y);
pc.printf("current_y: %f\n",current_y);
pc.printf("y_steps_to_take: %d\n",y_steps_to_take);
pc.printf("Y_TIME_FOR_MOVE: %f\n",Y_TIME_FOR_MOVE);
pc.printf("y_interval: %f\n\n",y_interval);
pc.printf("destination_z: %f\n",destination_z);
pc.printf("current_z: %f\n",current_z);
pc.printf("z_steps_to_take: %d\n",z_steps_to_take);
pc.printf("Z_TIME_FOR_MOVE: %f\n",Z_TIME_FOR_MOVE);
pc.printf("z_interval: %f\n\n",z_interval);
pc.printf("destination_e: %f\n",destination_e);
pc.printf("current_e: %f\n",current_e);
pc.printf("e_steps_to_take: %d\n",e_steps_to_take);
pc.printf("E_TIME_FOR_MOVE: %f\n",E_TIME_FOR_MOVE);
pc.printf("e_interval: %f\n\n",e_interval);
}
linear_move(); // make the move
ClearToSend();
return;
case 4: // G4 dwell
codenum = 0;
if (code_seen('P')) codenum = code_value(); // milliseconds to wait
if (code_seen('S')) codenum = code_value()*1000; // seconds to wait
previous_millis_heater = millis(); // keep track of when we started waiting
while ((millis() - previous_millis_heater) < codenum ) manage_heater(); //manage heater until time is up
break;
case 90: // G90
relative_mode = false;
break;
case 91: // G91
relative_mode = true;
break;
case 92: // G92
if (code_seen('X')) current_x = code_value();
if (code_seen('Y')) current_y = code_value();
if (code_seen('Z')) current_z = code_value();
if (code_seen('E')) current_e = code_value();
break;
case 93: // G93
pc.printf("previous_micros:%d\n", previous_micros);
pc.printf("previous_micros_x:%d\n", previous_micros_x);
pc.printf("previous_micros_y:%d\n", previous_micros_y);
pc.printf("previous_micros_z:%d\n", previous_micros_z);
break;
}
}
if (code_seen('M')) {
switch ( (int)code_value() ) {
case 104: // M104 - set hot-end temp
if (code_seen('S'))
{
target_raw = temp2analog(code_value());
//pc.printf("target_raw: %d\n ", target_raw);
}
break;
case 140: // M140 - set heated-printbed temp
if (code_seen('S'))
{
target_raw1 = temp2analog(code_value());
//pc.printf("target_raw1: %d\n ", target_raw);
}
break;
case 105: // M105
pc.printf("ok T:");
if (TEMP_0_PIN != NC) {
pc.printf("%f\n", analog2temp( (p_temp0.read_u16()) ));
} else {
pc.printf("0.0\n");
}
if (!code_seen('N')) return; // If M105 is sent from generated gcode, then it needs a response.
break;
case 109: // M109 - Wait for heater to reach target.
if (code_seen('S')) target_raw = temp2analog(code_value());
previous_millis_heater = millis();
while (current_raw < target_raw) {
if ( (millis()-previous_millis_heater) > 1000 ) { //Print Temp Reading every 1 second while heating up.
pc.printf("ok T:");
if (TEMP_0_PIN != NC) {
pc.printf("%f\n", analog2temp(p_temp0.read_u16()));
} else {
pc.printf("0.0\n");
}
previous_millis_heater = millis();
}
manage_heater();
}
break;
case 106: //M106 Fan On
p_fan = 1;
break;
case 107: //M107 Fan Off
p_fan = 0;
break;
case 80: // M81 - ATX Power On
//if(PS_ON_PIN > -1) pinMode(PS_ON_PIN,OUTPUT); //GND
break;
case 81: // M81 - ATX Power Off
//if(PS_ON_PIN > -1) pinMode(PS_ON_PIN,INPUT); //Floating
break;
case 82:
relative_mode_e = false;
break;
case 83:
relative_mode_e = true;
break;
case 84:
disable_x();
disable_y();
disable_z();
disable_e();
break;
case 85: // M85
code_seen('S');
max_inactive_time = code_value()*1000;
break;
case 86: // M86 If Endstop is Not Activated then Abort Print
if (code_seen('X')) {
if (X_MIN_PIN != NC) {
if ( p_X_min == ENDSTOPS_INVERTING ) {
kill(3);
}
}
}
if (code_seen('Y')) {
if (Y_MIN_PIN != NC) {
if ( p_Y_min == ENDSTOPS_INVERTING ) {
kill(4);
}
}
}
break;
case 92: // M92
if (code_seen('X')) x_steps_per_unit = code_value();
if (code_seen('Y')) y_steps_per_unit = code_value();
if (code_seen('Z')) z_steps_per_unit = code_value();
if (code_seen('E')) e_steps_per_unit = code_value();
break;
}
}
ClearToSend();
}
static void run_(testcase* test, const char* name)
{
fprintf(stderr, "\n[ ******** STARTING TESTCASE '%s' ******** ]\n", name);
reset_timers();
test();
}
agent * create_soar_agent (char * agent_name) { /* loop index */
char cur_path[MAXPATHLEN]; /* AGR 536 */
//agent* newAgent = static_cast<agent *>(malloc(sizeof(agent)));
agent* newAgent = new agent();
newAgent->current_tc_number = 0;
newAgent->name = savestring(agent_name);
/* mvp 5-17-94 */
newAgent->variables_set = NIL;
//#ifdef _WINDOWS
// newAgent->current_line[0] = 0;
// newAgent->current_line_index = 0;
//#endif /* _WINDOWS */
newAgent->all_wmes_in_rete = NIL;
newAgent->alpha_mem_id_counter = 0;
newAgent->alternate_input_string = NIL;
newAgent->alternate_input_suffix = NIL;
newAgent->alternate_input_exit = FALSE;/* Soar-Bugs #54 */
newAgent->backtrace_number = 0;
newAgent->beta_node_id_counter = 0;
newAgent->bottom_goal = NIL;
newAgent->changed_slots = NIL;
newAgent->chunk_count = 1;
newAgent->chunk_free_problem_spaces = NIL;
newAgent->chunky_problem_spaces = NIL; /* AGR MVL1 */
strcpy(newAgent->chunk_name_prefix,"chunk"); /* ajc (5/14/02) */
newAgent->context_slots_with_changed_acceptable_preferences = NIL;
newAgent->current_file = NIL;
newAgent->current_phase = INPUT_PHASE;
newAgent->applyPhase = FALSE;
newAgent->current_symbol_hash_id = 0;
newAgent->current_variable_gensym_number = 0;
newAgent->current_wme_timetag = 1;
newAgent->default_wme_depth = 1; /* AGR 646 */
newAgent->disconnected_ids = NIL;
newAgent->existing_output_links = NIL;
newAgent->output_link_changed = FALSE; /* KJC 11/9/98 */
/* newAgent->explain_flag = FALSE; */
newAgent->go_number = 1;
newAgent->go_type = GO_DECISION;
newAgent->init_count = 0;
newAgent->rl_init_count = 0;
newAgent->grounds_tc = 0;
newAgent->highest_goal_whose_context_changed = NIL;
newAgent->ids_with_unknown_level = NIL;
newAgent->input_period = 0; /* AGR REW1 */
newAgent->input_cycle_flag = TRUE; /* AGR REW1 */
newAgent->justification_count = 1;
newAgent->lex_alias = NIL; /* AGR 568 */
newAgent->link_update_mode = UPDATE_LINKS_NORMALLY;
newAgent->locals_tc = 0;
newAgent->max_chunks_reached = FALSE; /* MVP 6-24-94 */
newAgent->mcs_counter = 1;
newAgent->memory_pools_in_use = NIL;
newAgent->ms_assertions = NIL;
newAgent->ms_retractions = NIL;
newAgent->num_existing_wmes = 0;
newAgent->num_wmes_in_rete = 0;
newAgent->potentials_tc = 0;
newAgent->prev_top_state = NIL;
newAgent->print_prompt_flag = TRUE;
newAgent->printer_output_column = 1;
newAgent->production_being_fired = NIL;
newAgent->productions_being_traced = NIL;
newAgent->promoted_ids = NIL;
newAgent->reason_for_stopping = "Startup";
newAgent->slots_for_possible_removal = NIL;
newAgent->stop_soar = TRUE;
newAgent->system_halted = FALSE;
newAgent->token_additions = 0;
newAgent->top_dir_stack = NIL; /* AGR 568 */
newAgent->top_goal = NIL;
newAgent->top_state = NIL;
newAgent->wmes_to_add = NIL;
newAgent->wmes_to_remove = NIL;
newAgent->wme_filter_list = NIL; /* Added this to avoid
access violation
-AJC (5/13/02) */
newAgent->multi_attributes = NIL;
/* REW: begin 09.15.96 */
newAgent->did_PE = FALSE;
newAgent->soar_verbose_flag = FALSE;
newAgent->FIRING_TYPE = IE_PRODS;
newAgent->ms_o_assertions = NIL;
newAgent->ms_i_assertions = NIL;
/* REW: end 09.15.96 */
newAgent->postponed_assertions = NIL;
/* REW: begin 08.20.97 */
newAgent->active_goal = NIL;
newAgent->active_level = 0;
newAgent->previous_active_level = 0;
/* Initialize Waterfall-specific lists */
newAgent->nil_goal_retractions = NIL;
/* REW: end 08.20.97 */
/* REW: begin 10.24.97 */
newAgent->waitsnc = FALSE;
newAgent->waitsnc_detect = FALSE;
/* REW: end 10.24.97 */
/* Initializing rete stuff */
for (int i=0; i < 256; i++) {
newAgent->actual[i]=0;
newAgent->if_no_merging[i]=0;
newAgent->if_no_sharing[i]=0;
}
/* Initializing lexeme */
newAgent->lexeme.type = NULL_LEXEME;
newAgent->lexeme.string[0] = 0;
newAgent->lexeme.length = 0;
newAgent->lexeme.int_val = 0;
newAgent->lexeme.float_val = 0.0;
newAgent->lexeme.id_letter = 'A';
newAgent->lexeme.id_number = 0;
reset_max_stats(newAgent);
newAgent->real_time_tracker = 0;
newAgent->attention_lapse_tracker = 0;
if(!getcwd(cur_path, MAXPATHLEN))
print(newAgent, "Unable to set current directory while initializing agent.\n");
newAgent->top_dir_stack = static_cast<dir_stack_struct *>(malloc(sizeof(dir_stack_struct))); /* AGR 568 */
newAgent->top_dir_stack->directory = static_cast<char *>(malloc(MAXPATHLEN*sizeof(char))); /* AGR 568 */
newAgent->top_dir_stack->next = NIL; /* AGR 568 */
strcpy(newAgent->top_dir_stack->directory, cur_path); /* AGR 568 */
/* changed all references of 'i', a var belonging to a previous for loop, to 'productionTypeCounter' to be unique
stokesd Sept 10 2004*/
for (int productionTypeCounter=0; productionTypeCounter<NUM_PRODUCTION_TYPES; productionTypeCounter++) {
newAgent->all_productions_of_type[productionTypeCounter] = NIL;
newAgent->num_productions_of_type[productionTypeCounter] = 0;
}
newAgent->o_support_calculation_type = 4; /* KJC 7/00 */ // changed from 3 to 4 by voigtjr (/* bugzilla bug 339 */)
newAgent->numeric_indifferent_mode = NUMERIC_INDIFFERENT_MODE_SUM;
/* JC ADDED: Make sure that the RHS functions get initialized correctly */
newAgent->rhs_functions = NIL;
// JRV: Allocates data for XML generation
xml_create( newAgent );
soar_init_callbacks( newAgent );
//
// This call is needed to set up callbacks.
init_memory_utilities(newAgent);
//
// This was moved here so that system parameters could
// be set before the agent was initialized.
init_sysparams (newAgent);
/* Initializing all the timer structures */
// Timers must be initialized after sysparams
#ifndef NO_TIMING_STUFF
newAgent->timers_cpu.set_enabled(&(newAgent->sysparams[TIMERS_ENABLED]));
newAgent->timers_kernel.set_enabled(&(newAgent->sysparams[TIMERS_ENABLED]));
newAgent->timers_phase.set_enabled(&(newAgent->sysparams[TIMERS_ENABLED]));
#ifdef DETAILED_TIMING_STATS
newAgent->timers_gds.set_enabled(&(newAgent->sysparams[TIMERS_ENABLED]));
#endif
reset_timers(newAgent);
#endif
// dynamic memory pools (should come before consumers of dynamic pools)
newAgent->dyn_memory_pools = new std::map< size_t, memory_pool* >();
// dynamic counters
newAgent->dyn_counters = new std::map< std::string, uint64_t >();
// exploration initialization
newAgent->exploration_params[ EXPLORATION_PARAM_EPSILON ] = exploration_add_parameter( 0.1, &exploration_validate_epsilon, "epsilon" );
newAgent->exploration_params[ EXPLORATION_PARAM_TEMPERATURE ] = exploration_add_parameter( 25, &exploration_validate_temperature, "temperature" );
// rl initialization
newAgent->rl_params = new rl_param_container( newAgent );
newAgent->rl_stats = new rl_stat_container( newAgent );
newAgent->rl_prods = new rl_production_memory();
rl_initialize_template_tracking( newAgent );
// select initialization
newAgent->select = new select_info;
select_init( newAgent );
// predict initialization
newAgent->prediction = new std::string();
predict_init( newAgent );
// wma initialization
newAgent->wma_params = new wma_param_container( newAgent );
newAgent->wma_stats = new wma_stat_container( newAgent );
newAgent->wma_timers = new wma_timer_container( newAgent );
#ifdef USE_MEM_POOL_ALLOCATORS
newAgent->wma_forget_pq = new wma_forget_p_queue( std::less< wma_d_cycle >(), soar_module::soar_memory_pool_allocator< std::pair< wma_d_cycle, wma_decay_set* > >( newAgent ) );
newAgent->wma_touched_elements = new wma_pooled_wme_set( std::less< wme* >(), soar_module::soar_memory_pool_allocator< wme* >( newAgent ) );
newAgent->wma_touched_sets = new wma_decay_cycle_set( std::less< wma_d_cycle >(), soar_module::soar_memory_pool_allocator< wma_d_cycle >( newAgent ) );
#else
newAgent->wma_forget_pq = new wma_forget_p_queue();
newAgent->wma_touched_elements = new wma_pooled_wme_set();
newAgent->wma_touched_sets = new wma_decay_cycle_set();
#endif
newAgent->wma_initialized = false;
newAgent->wma_tc_counter = 2;
// epmem initialization
newAgent->epmem_params = new epmem_param_container( newAgent );
newAgent->epmem_stats = new epmem_stat_container( newAgent );
newAgent->epmem_timers = new epmem_timer_container( newAgent );
newAgent->epmem_db = new soar_module::sqlite_database();
newAgent->epmem_stmts_common = NULL;
newAgent->epmem_stmts_graph = NULL;
newAgent->epmem_node_mins = new std::vector<epmem_time_id>();
newAgent->epmem_node_maxes = new std::vector<bool>();
newAgent->epmem_edge_mins = new std::vector<epmem_time_id>();
newAgent->epmem_edge_maxes = new std::vector<bool>();
newAgent->epmem_id_repository = new epmem_parent_id_pool();
newAgent->epmem_id_replacement = new epmem_return_id_pool();
newAgent->epmem_id_ref_counts = new epmem_id_ref_counter();
// debug module settings
newAgent->debug_params = new debug_param_container( newAgent );
#ifdef USE_MEM_POOL_ALLOCATORS
newAgent->epmem_node_removals = new epmem_id_removal_map( std::less< epmem_node_id >(), soar_module::soar_memory_pool_allocator< std::pair< epmem_node_id, bool > >( newAgent ) );
newAgent->epmem_edge_removals = new epmem_id_removal_map( std::less< epmem_node_id >(), soar_module::soar_memory_pool_allocator< std::pair< epmem_node_id, bool > >( newAgent ) );
newAgent->epmem_wme_adds = new epmem_symbol_set( std::less< Symbol* >(), soar_module::soar_memory_pool_allocator< Symbol* >( newAgent ) );
newAgent->epmem_promotions = new epmem_symbol_set( std::less< Symbol* >(), soar_module::soar_memory_pool_allocator< Symbol* >( newAgent ) );
newAgent->epmem_id_removes = new epmem_symbol_stack( soar_module::soar_memory_pool_allocator< Symbol* >( newAgent ) );
#else
newAgent->epmem_node_removals = new epmem_id_removal_map();
newAgent->epmem_edge_removals = new epmem_id_removal_map();
newAgent->epmem_wme_adds = new epmem_symbol_set();
newAgent->epmem_promotions = new epmem_symbol_set();
newAgent->epmem_id_removes = new epmem_symbol_stack();
#endif
newAgent->epmem_validation = 0;
// smem initialization
newAgent->smem_params = new smem_param_container( newAgent );
newAgent->smem_stats = new smem_stat_container( newAgent );
newAgent->smem_timers = new smem_timer_container( newAgent );
newAgent->smem_db = new soar_module::sqlite_database();
newAgent->smem_validation = 0;
#ifdef USE_MEM_POOL_ALLOCATORS
newAgent->smem_changed_ids = new smem_pooled_symbol_set( std::less< Symbol* >(), soar_module::soar_memory_pool_allocator< Symbol* >( newAgent ) );
#else
newAgent->smem_changed_ids = new smem_pooled_symbol_set();
#endif
newAgent->smem_ignore_changes = false;
// statistics initialization
newAgent->dc_stat_tracking = false;
newAgent->stats_db = new soar_module::sqlite_database();
newAgent->substate_break_level = 0;
return newAgent;
}
