Method SingleProcess

avida-core/source/cpu/cHardwareBCR.cc:435–612

bool cHardwareBCR::SingleProcess(cAvidaContext& ctx, bool speculative)
{
  // If speculatively stalled, stay that way until a real instruction comes
  if (speculative && m_spec_stall) return false;
  
  
  // Mark this organism as running...
  m_organism->SetRunning(true);
  
  
  // Handle if this organism died while speculatively executing
  if (!speculative && m_spec_die) {
    m_organism->Die(ctx);
    m_organism->SetRunning(false);
    return false;
  }
  

  cPhenotype& phenotype = m_organism->GetPhenotype();
  
  
  if (m_spec_stall) {
    m_spec_stall = false;
  } else {
    // Update cycle counts
    m_cycle_count++;
    phenotype.IncCPUCyclesUsed();
    if (!m_no_cpu_cycle_time) phenotype.IncTimeUsed();

    // Wake any stalled threads
    for (int i = 0; i < m_threads.GetSize(); i++) {
      if (!m_threads[i].active && m_threads[i].wait_reg == -1) m_threads[i].active = true;
    }

    // Reset behavioral class 
    m_behav_class_used[0] = false;
    m_behav_class_used[1] = false;
    m_behav_class_used[2] = false;
    
    // Reset execution state
    m_cur_uop = 0;
    m_cur_thread = 0;
  }
  
  // Execute specified number of micro ops per cpu cycle on each thread in a round robin fashion
  const int uop_ratio = m_inst_set->GetUOpsPerCycle();
  for (; m_cur_uop < uop_ratio; m_cur_uop++) {
    for (m_cur_thread = (m_cur_thread < m_threads.GetSize()) ? m_cur_thread : 0; m_cur_thread < m_threads.GetSize(); m_cur_thread++) {
      // Setup the hardware for the next instruction to be executed.
      
      // If the currently selected thread is inactive, proceed to the next thread
      if (!m_threads[m_cur_thread].running || !m_threads[m_cur_thread].active) continue;
      
      m_advance_ip = true;
      Head& ip = m_threads[m_cur_thread].heads[hIP];
      ip.Adjust();
      
      // Print the status of this CPU at each step...