public void issue_Age() { // This is the original function - just changed its name to issue_Age: issue oldest ready instructions first
        int count = 0; //count the number of instructions to issue in current cycle
        ROB_entry[] currentCycleIssuedInstr=new ROB_entry[machineWidth];
        
        for (Iterator<ROB_entry> itr = ROB.entries.iterator(); itr.hasNext(); )  {
            ROB_entry currEntry = itr.next();
            Uop currUop = currEntry.theUop;
            
            if (!currEntry.hasIssued_f && isUopReady(currEntry, currentCycleIssuedInstr,count)) { // make sure inputs are ready, etc.
                currEntry.hasIssued_f = true;
                currEntry.issueCycle = currCycle;
                currEntry.doneCycle = currCycle + currUop.exec_latency;
                currentCycleIssuedInstr[count] = currEntry;
                
                if (!perfectCache_f && currUop.isMem()) {
                    myCache.access(currUop.addressForMemoryOp, currUop.isLoad());
                    myCacheStats.updateStat(myCache.hit_f);
                    
                    if (currUop.isLoad() && !myCache.hit_f){// load misses cost more
                        currEntry.doneCycle = currCycle + cacheMissPenalty;
                    }
                }
                
                if (currEntry.mispredictedBranch_f) {
                    SimAssert.check (fetchReady == -1, "should be stalling fetch until mis-predicted branch executes", currCycle); 
                    fetchReady = currEntry.theUop.exec_latency + bpredPenalty;  // The mis-prediction restart penalty
                }
                
                updateScoreboard(currEntry);
                
                count = count + 1;
                if (count == machineWidth) {
                    break;  // stop looking for instructions to execute
                }
            }
        }
    }