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