void CWZStep3::OnAdd() { int nTotal,i; WCHAR szPath[MAX_PATH]; CString strPath; UpdateData(TRUE); if (GetLongPathName(m_SourcePath.GetBuffer(0),szPath,MAX_PATH)) { m_SourcePath = szPath; nTotal = m_SourceList.GetItemCount(); for (i = 0;i < nTotal;i++) { strPath = m_SourceList.GetItemText(i,0); if (CheckConflict(strPath.GetBuffer(0),szPath,FALSE)) return; if (CheckConflict(szPath,strPath.GetBuffer(0),FALSE)) { m_SourceList.DeleteItem(i); nTotal --; i --; } } m_SourceList.InsertItem(nTotal,m_SourcePath); m_SourceList.SetItem(nTotal,0,LVIF_STATE,L"",0,INDEXTOSTATEIMAGEMASK(1),LVIS_STATEIMAGEMASK,0); } else AfxMessageBox(IDS_INVALID_SOURCE,MB_OK | MB_ICONINFORMATION); // TODO: Add your control notification handler code here }
// // Notes: // xi: operation node xi whose id is i // // i starts off at MAX_PORT_NU // void Enumerate(int *ASAP_slots, int *ALAP_slots, int i) { int first, last; int step; int cur_latency; int cur_mux_fanin; int cur_mux_fanout = 0; int cur_mux_input; int cur_muxp_input; int cur_muxr_input; int cur_reg_nu; int fuNu; // functional unit number static int best_latency = 100000; //------------------------------------------------------------ // vars to support GenerateBackEnd char scheduleName[10]; ScheduleStats SS[3]; // ASAP, ALAP, Iter //------------------------------------------------------------ if (i == NODE_NU) { myprintf("enumeration hit the last node\n"); CheckConflict(); if (min_mux_fanin == 2) { fprintf(stderr, "\nfanin = 2\n"); fprintf(stderr, "Cur Enum mux fanout (%d %d)\n", min_mux_fanout, max_mux_fanout); fprintf(stderr, "Cur Enum mux fanin (%d %d)\n", min_mux_fanin, max_mux_fanin); fprintf(stderr, "Cur Enum muxp input (%d %d)\n", min_muxp_input, max_muxp_input); fprintf(stderr, "Cur Enum muxr input (%d %d)\n", min_muxr_input, max_muxr_input); fprintf(stderr, "Cur Enum mux input (%d %d)\n", min_mux_input, max_mux_input); fprintf(stderr, "Cur Enum reg number(%d %d)\n", min_reg_nu, max_reg_nu); fprintf(stderr, "Cur Enum latency (%d %d)\n", min_latency, max_latency); PrintDFG(ASAP_slots, ALAP_slots); exit(0); } if (max_mux_fanin == 6) { fprintf(stderr, "\nfanin = 6\n"); fprintf(stderr, "Cur Enum mux fanout (%d %d)\n", min_mux_fanout, max_mux_fanout); fprintf(stderr, "Cur Enum mux fanin (%d %d)\n", min_mux_fanin, max_mux_fanin); fprintf(stderr, "Cur Enum muxp input (%d %d)\n", min_muxp_input, max_muxp_input); fprintf(stderr, "Cur Enum muxr input (%d %d)\n", min_muxr_input, max_muxr_input); fprintf(stderr, "Cur Enum mux input (%d %d)\n", min_mux_input, max_mux_input); fprintf(stderr, "Cur Enum reg number(%d %d)\n", min_reg_nu, max_reg_nu); fprintf(stderr, "Cur Enum latency (%d %d)\n", min_latency, max_latency); //PrintDFG(ASAP_slots, ALAP_slots); exit(0); } ENUM_NU++; if (fmod(ENUM_NU, 1000) == 0) { //fprintf(stderr, "progress %lf%\n", ENUM_NU / ENUM_SZ * 100); fprintf(stderr, "progress %lf\n", ENUM_NU); fprintf(stderr, "Cur Enum mux fanout (%d %d)\n", min_mux_fanout, max_mux_fanout); fprintf(stderr, "Cur Enum mux fanin (%d %d)\n", min_mux_fanin, max_mux_fanin); fprintf(stderr, "Cur Enum muxp input (%d %d)\n", min_muxp_input, max_muxp_input); fprintf(stderr, "Cur Enum muxr input (%d %d)\n", min_muxr_input, max_muxr_input); fprintf(stderr, "Cur Enum mux input (%d %d)\n", min_mux_input, max_mux_input); fprintf(stderr, "Cur Enum reg number(%d %d)\n", min_reg_nu, max_reg_nu); fprintf(stderr, "Cur Enum latency (%d %d)\n", min_latency, max_latency); printf("stopped at 10000\n"); exit(0); if (ENUM_NU > 1000000) return; //if (ENUM_NU == 60000) getchar(); } // Debug spot // cur_latency = DFG[NODE_NU-1]->opScheduledSlot + DFG[NODE_NU-1]->opLatency + 1; myprintf("current latency = %d\n", cur_latency); if (min_latency > cur_latency) { min_latency = cur_latency; } if (max_latency < cur_latency) { max_latency = cur_latency; } // GenerateBackEnd(stderr, scheduleName, "Iter", PORT_NU, cur_latency, SS); if (cur_mux_fanout < CSP->rfo) cur_mux_fanout = CSP->rfo; if (cur_mux_fanout < CSP->pfo) cur_mux_fanout = CSP->pfo; if (cur_mux_fanout < CSP->ffo) cur_mux_fanout = CSP->ffo; cur_mux_fanin = CSP->fan; cur_mux_input = CSP->mux; cur_muxp_input = CSP->muxp; cur_muxr_input = CSP->muxr; cur_reg_nu = CSP->reg; // best_mux_fanout if (min_mux_fanout > cur_mux_fanout) { min_mux_fanout = cur_mux_fanout; } if (max_mux_fanout < cur_mux_fanout) { max_mux_fanout = cur_mux_fanout; } // best_reg_nu if (min_reg_nu > cur_reg_nu) { min_reg_nu = cur_reg_nu; } if (max_reg_nu < cur_reg_nu) { max_reg_nu = cur_reg_nu; } // best_mux_input if (min_mux_input > cur_mux_input) { min_mux_input = cur_mux_input; } if (max_mux_input < cur_mux_input) { max_mux_input = cur_mux_input; } // best_muxp_input if (min_muxp_input > cur_muxp_input) { min_muxp_input = cur_muxp_input; } if (max_muxp_input < cur_muxp_input) { max_muxp_input = cur_muxp_input; } // best_muxr_input if (min_muxr_input > cur_muxr_input) { min_muxr_input = cur_muxr_input; } if (max_muxr_input < cur_muxr_input) { max_muxr_input = cur_muxr_input; } // best_mux_fanin if (min_mux_fanin > cur_mux_fanin) { min_mux_fanin = cur_mux_fanin; } if (max_mux_fanin < cur_mux_fanin) { max_mux_fanin = cur_mux_fanin; } } else { first = ASAP_slots[i]; last = ALAP_slots[i]; /* if (ASAP_slots[i] < ALAP_slots[i]) { first = ASAP_slots[i]; last = ALAP_slots[i]; } else { // ALAP has shorter latency first = ALAP_slots[i]; last = ASAP_slots[i]; // update ASAP/ALAP slots ASAP_slots[i] = first; ALAP_slots[i] = last; } */ int step_size, step_range; assert(last >= first); step_range = last - first + 1; /* ordbbr if (step_range > 60) step_size = 30; //10; else if (step_range > 40) step_size = 20; //10; else if (step_range > 30) step_size = 15; //8; else if (step_range > 20) step_size = 10; //6; else if (step_range > 10) step_size = 5; else if (step_range > 2) step_size = 2; else step_size = 1; // for ordbur, ppbr if (step_range > 40) step_size = 10; else if (step_range > 30) step_size = 8; else if (step_range > 20) step_size = 6; else if (step_range > 10) step_size = 4; else if (step_range > 2) step_size = 2; else step_size = 1; */ step_size = 1; myprintf("enum %lf debug mobility step: %d [%d %d]\n", ENUM_NU, step_size, first, last); //for (step = first; step <= last; step++) { for (step = first; step <= last; step += step_size) { myprintf("Try step %d of DFG node %d [%d %d]\n", step, i, first, last); // save ASAP values int *save_ASAP_slots = (int *) malloc (sizeof(int) * NODE_NU); int *save_ALAP_slots = (int *) malloc (sizeof(int) * NODE_NU); memcpy(save_ASAP_slots, ASAP_slots, NODE_NU * sizeof(int)); memcpy(save_ALAP_slots, ALAP_slots, NODE_NU * sizeof(int)); // ResourceUsed (step, type(xi)) // Increment ResourceUsed (step, type(xi)) if ((fuNu = InsertScheduleRAT(DFG[i]->op, step)) != -1) { // S(i) = step // Specificaly, update the operator's start and end time DFG[i]->opScheduledSlot = step; DFG[i]->opResultDoneSlot = step + DFG[i]->opLatency; DFG[i]->opResourceNu = fuNu + 1; myprintf("DFG node %d has resourceNu %d\n", i, fuNu); UpdateASAP(i, ASAP_slots, ALAP_slots, step); myprintf("Start enumerating at DFG node %d\n", i+1); Enumerate(ASAP_slots, ALAP_slots, i+1); myprintf("Return from enumerating at DFG node %d\n", i+1); DecScheduleRAT(i, step); } // restore ASAP values memcpy(ASAP_slots, save_ASAP_slots, NODE_NU * sizeof(int)); memcpy(ALAP_slots, save_ALAP_slots, NODE_NU * sizeof(int)); free(save_ASAP_slots); free(save_ALAP_slots); } } }
void PortDirectedSchedule(FILE *fp, int portConfigCnt, int MAX_PORT_NU, int *ASAP_slots, int *ALAP_slots, int *Xconstraint, int *Kconstraint, ScheduleStats SS[]) { char scheduleName[10]; char make_cmd[50]; // Scheduled FUs int ASAP_resource, ALAP_resource, List_resource, Iter_resource; // Data path DII int ASAP_DII, ALAP_DII; // Data path delay int ASAP_delay, ALAP_delay, List_delay, delay; //--------------------------------------------- // ASAP //--------------------------------------------- myprintf("********* ASAP Start ********* \n"); ASAP_delay = ASAP(ASAP_slots, Xconstraint, Kconstraint); ASAP_DII = CheckConflict(); ASAP_resource = CountResource(); //PrintDFG(ASAP_slots, ALAP_slots); CSP->dly = ASAP_delay; PrintStats(fp, "ASAP", ASAP_DII, ASAP_resource, ASAP_delay); myprintf("********* ASAP Scheduling Done ********* \n"); //goto ALAP_SCH; GenerateBackEnd(fp, scheduleName, "ASAP", portConfigCnt, ASAP_delay, SS); myprintf("********* ASAP Generation Done ********* \n"); //exit(1); #ifdef MODELSIM printf("**************************************************\n"); printf("* Testing circuit ASAP%d_%s\n", portConfigCnt, CircuitName); printf("**************************************************\n"); fflush(stdout); make_cmd[0] = '\0'; sprintf(make_cmd, "make ASAP%d_%s", portConfigCnt, CircuitName); if (system(make_cmd) != 0) { printf("********* ASAP system(make_cmd) Error ********* \n"); exit(-1); } printf("**************************************************\n"); printf("* Done Testing circuit ASAP%d_%s\n", portConfigCnt, CircuitName); printf("**************************************************\n"); #endif printf("---------------------------\n"); printf("ASAP regs fanout (%d)\n", CSP->rfo); printf("ASAP func fanout (%d)\n", CSP->ffo); printf("ASAP port fanout (%d)\n", CSP->pfo); printf("ASAP mux chain reg (%d)\n", CSP->mux_reg); printf("ASAP mux fanin (%d)\n", CSP->fan); printf("ASAP mux input (%d)\n", CSP->mux); printf("ASAP muxp input (%d)\n", CSP->muxp); printf("ASAP muxr input (%d)\n", CSP->muxr); printf("ASAP reg number(%d)\n", CSP->reg); printf("ASAP latency (%d)\n", CSP->dly); ALAP_SCH: ResetResource(); ResetRAT(); #ifdef CSV fprintf(csv[0][REG], ",%d", CSP->reg); fprintf(csv[0][DLY], ",%d", CSP->dly); fprintf(csv[0][MUX], ",%d", CSP->mux); fprintf(csv[0][FAN], ",%d", CSP->fan); #endif return; // just ASAP results //--------------------------------------------- // ALAP //--------------------------------------------- myprintf("********* ALAP Start ********* \n"); ALAP_delay = ALAP(ALAP_slots, MAX_PORT_NU); ALAP_DII = CheckConflict(); ALAP_resource = CountResource(); CSP->dly = ALAP_delay; //PrintDFG(ASAP_slots, ALAP_slots); PrintStats(fp, "ALAP", ALAP_DII, ALAP_resource, ALAP_delay); myprintf("********* ALAP Scheduling Done ********* \n"); goto ENUM_SCH; //return; GenerateBackEnd(fp, scheduleName, "ALAP", portConfigCnt, ALAP_delay, SS); myprintf("********* ALAP Generation Done ********* \n"); #ifdef MODELSIM printf("**************************************************\n"); printf("* Testing circuit ALAP%d_%s\n", portConfigCnt, CircuitName); printf("**************************************************\n"); make_cmd[0] = '\0'; sprintf(make_cmd, "make ALAP%d_%s", portConfigCnt, CircuitName); system(make_cmd); printf("**************************************************\n"); printf("* Done Testing circuit ALAP%d_%s\n", portConfigCnt, CircuitName); printf("**************************************************\n"); #endif fprintf(stderr, "---------------------------\n"); fprintf(stderr, "ALAP regs fanout (%d)\n", CSP->rfo); fprintf(stderr, "ALAP func fanout (%d)\n", CSP->ffo); fprintf(stderr, "ALAP port fanout (%d)\n", CSP->pfo); fprintf(stderr, "ALAP mux fanin (%d)\n", CSP->fan); fprintf(stderr, "ALAP mux input (%d)\n", CSP->mux); fprintf(stderr, "ALAP muxp input (%d)\n", CSP->muxp); fprintf(stderr, "ALAP muxr input (%d)\n", CSP->muxr); fprintf(stderr, "ALAP reg number(%d)\n", CSP->reg); fprintf(stderr, "ALAP latency (%d)\n", CSP->dly); ENUM_SCH: ResetResource(); ResetRAT(); #ifdef CSV fprintf(csv[1][REG], ",%d", CSP->reg); fprintf(csv[1][DLY], ",%d", CSP->dly); fprintf(csv[1][MUX], ",%d", CSP->mux); fprintf(csv[1][FAN], ",%d", CSP->fan); #endif myprintf("********* Enumeration Scheduling Start ********* \n"); CreateScheduleRAT(); int i; int first, last; // The product of all the mobilities. The size of some benchmarks are too big for (i = MAX_PORT_NU; i < NODE_NU; i++) { if (ASAP_slots[i] > ALAP_slots[i]) { // update ASAP/ALAP slots if ALAP has shorter latency first = ALAP_slots[i]; last = ASAP_slots[i]; ASAP_slots[i] = first; ALAP_slots[i] = last; } if (ALAP_slots[i] - ASAP_slots[i] > 0) ENUM_SZ *= ALAP_slots[i] - ASAP_slots[i] + 1; } fprintf(stderr, "Est. Schedule enum space size %lf\n", ENUM_SZ); // A naive branch and bound complete enumeration method Enumerate (ASAP_slots, ALAP_slots, MAX_PORT_NU); fprintf(stderr, "Act. Schedule enum number = %lf\n", ENUM_NU); fprintf(stderr, "---------------------------\n"); fprintf(stderr, "Enum mux fanout (%d %d)\n", min_mux_fanout, max_mux_fanout); fprintf(stderr, "Enum mux fanin (%d %d)\n", min_mux_fanin, max_mux_fanin); fprintf(stderr, "Enum mux input (%d %d)\n", min_mux_input, max_mux_input); fprintf(stderr, "Enum muxp input (%d %d)\n", min_muxp_input, max_muxp_input); fprintf(stderr, "Enum muxr input (%d %d)\n", min_muxr_input, max_muxr_input); fprintf(stderr, "Enum reg number(%d %d)\n", min_reg_nu, max_reg_nu); fprintf(stderr, "Enum latency (%d %d)\n", min_latency, max_latency); FreeScheduleRAT(); //PrintDFG(ASAP_slots, ALAP_slots); // }