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