void main()
{
InitSystemClock();
InitPortsIO();
InitTimers();
EnableInterrupts();
while (1)
{
GENSendPacketIR(0x00,0xF7,0x20,0xDF); //Led "Game"
GENDelay100Us(500);
GENSendPacketIR(0x00,0xF7,0xA0,0x5E); //Led "TV"
GENDelay100Us(500);
GENSendPacketIR(0x00,0xFC,0xA1,0x5E); //Led "DVD"
GENDelay100Us(500);
/*GENSendPacketIR(0x03,0xFC,0x51,0xAE); //Led "CD/MP3"
GENDelay100Us(500);
GENSendPacketIR(0x03,0xFC,0x11,0xEE); //Led "Game"
GENDelay100Us(500);
GENSendPacketIR(0x03,0xFC,0xB1,0x4E); //Led "TV"
GENDelay100Us(500);
GENSendPacketIR(0x03,0xFC,0xA1,0x5E); //Led "DVD"
GENDelay100Us(500);
GENSendPacketIR(0x03,0xFC,0xB1,0x4E); //Led "TV"
GENDelay100Us(500);
GENSendPacketIR(0x03,0xFC,0x11,0xEE); //Led "Game"
GENDelay100Us(500); */
}
}
/***********************************************************************************
* This function is the entry point of the parallel ordering algorithm.
* This function assumes that the graph is already nice partitioned among the
* processors and then proceeds to perform recursive bisection.
************************************************************************************/
void ParMETIS_V3_PartGeom(idxtype *vtxdist, int *ndims, float *xyz, idxtype *part, MPI_Comm *comm)
{
int i, npes, mype, nvtxs, firstvtx, dbglvl;
idxtype *xadj, *adjncy;
CtrlType ctrl;
WorkSpaceType wspace;
GraphType *graph;
int zeroflg = 0;
MPI_Comm_size(*comm, &npes);
MPI_Comm_rank(*comm, &mype);
if (npes == 1) {
idxset(vtxdist[mype+1]-vtxdist[mype], 0, part);
return;
}
/* Setup a fake graph to allow the rest of the code to work unchanged */
dbglvl = 0;
nvtxs = vtxdist[mype+1]-vtxdist[mype];
firstvtx = vtxdist[mype];
xadj = idxmalloc(nvtxs+1, "ParMETIS_PartGeom: xadj");
adjncy = idxmalloc(nvtxs, "ParMETIS_PartGeom: adjncy");
for (i=0; i<nvtxs; i++) {
xadj[i] = i;
adjncy[i] = firstvtx + (i+1)%nvtxs;
}
xadj[nvtxs] = nvtxs;
/* Proceed with the rest of the code */
SetUpCtrl(&ctrl, npes, dbglvl, *comm);
ctrl.seed = mype;
ctrl.CoarsenTo = amin(vtxdist[npes]+1, 25*npes);
graph = Moc_SetUpGraph(&ctrl, 1, vtxdist, xadj, NULL, adjncy, NULL, &zeroflg);
PreAllocateMemory(&ctrl, graph, &wspace);
/*=======================================================
* Compute the initial geometric partitioning
=======================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
Coordinate_Partition(&ctrl, graph, *ndims, xyz, 0, &wspace);
idxcopy(graph->nvtxs, graph->where, part);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimingInfo(&ctrl));
FreeInitialGraphAndRemap(graph, 0);
FreeWSpace(&wspace);
FreeCtrl(&ctrl);
GKfree((void **)&xadj, (void **)&adjncy, LTERM);
}
/*************************************************************************
* This function is the entry point for PWMETIS that accepts exact weights
* for the target partitions
**************************************************************************/
void METIS_WPartGraphRecursive(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts,
floattype *tpwgts, int *options, int *edgecut, idxtype *part)
{
int i, j;
GraphType graph;
CtrlType ctrl;
floattype *mytpwgts;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
SetUpGraph(&graph, OP_PMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = PMETIS_CTYPE;
ctrl.IType = PMETIS_ITYPE;
ctrl.RType = PMETIS_RTYPE;
ctrl.dbglvl = PMETIS_DBGLVL;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
}
ctrl.optype = OP_PMETIS;
ctrl.CoarsenTo = 20;
ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt)/ctrl.CoarsenTo);
mytpwgts = fmalloc(*nparts, "PWMETIS: mytpwgts");
for (i=0; i<*nparts; i++)
mytpwgts[i] = tpwgts[i];
InitRandom(-1);
AllocateWorkSpace(&ctrl, &graph, *nparts);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
*edgecut = MlevelRecursiveBisection(&ctrl, &graph, *nparts, part, mytpwgts, 1.000, 0);
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
FreeWorkSpace(&ctrl, &graph);
free(mytpwgts);
if (*numflag == 1)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
}
/*************************************************************************
* This function is the entry point for OEMETIS
**************************************************************************/
void METIS_EdgeND(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options,
idxtype *perm, idxtype *iperm)
{
int i, j;
GraphType graph;
CtrlType ctrl;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
SetUpGraph(&graph, OP_OEMETIS, *nvtxs, 1, xadj, adjncy, NULL, NULL, 0);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = OEMETIS_CTYPE;
ctrl.IType = OEMETIS_ITYPE;
ctrl.RType = OEMETIS_RTYPE;
ctrl.dbglvl = OEMETIS_DBGLVL;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
}
ctrl.oflags = 0;
ctrl.pfactor = -1;
ctrl.nseps = 1;
ctrl.optype = OP_OEMETIS;
ctrl.CoarsenTo = 20;
ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt)/ctrl.CoarsenTo);
InitRandom(-1);
AllocateWorkSpace(&ctrl, &graph, 2);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, *nvtxs);
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
for (i=0; i<*nvtxs; i++)
perm[iperm[i]] = i;
FreeWorkSpace(&ctrl, &graph);
if (*numflag == 1)
Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
}
/**
* @fn void MCUInit()
*
* @brief Sets the microcontroller to a predetermined state. Handles initialization
* for all categories of peripherals: Analog, Architecture, Communication,
* Data Converters, GPIO, LCD, Special Modules, Timers.
*
*/
void MCUInit()
{
#if defined(__MCU_MSP430_SERIES)
InitAnalog(); // Initialize the Analog modules
InitArchitecture(); // Initialize the Architecture modules
InitCommunication(); // Initialize the Communication modules
InitDataConverters(); // Initialize the Data Converter modules
InitGPIO(); // Initialize the GPIO modules
InitLCD(); // Initialize the LCD modules
InitSpecialModules(); // Initialize the Special modules
InitTimers(); // Initialize the Timers modules
#endif
}
/*
* Initialize the board
* Timers, Communication, etc
* Note : Should only be called once at the begginning of the main
*/
void InitBoard(void)
{
// Initialize clock
SYSTEMConfigPerformance(GetSystemClock());
SYSTEMConfig(GetSystemClock(), SYS_CFG_PCACHE);
SYSTEMConfig(GetSystemClock(), SYS_CFG_PB_BUS);
SYSTEMConfigPB(GetSystemClock());
INTEnableSystemMultiVectoredInt();
//Disable JTAG port
DDPCONbits.JTAGEN = 0;
// Initialize LEDs
LED1_TRIS = 0;
LED2_TRIS = 0;
// Initialize Timers
InitTimers();
// Initialize CAN bus
CRX1_TRIS = 1;
CTX1_TRIS = 0;
netv_init_can_driver(GetBoardID(),CAN1);
// Initialize digital IOs as inputs
DIO_TRIS |= DIO_MASK;
// Initialize Relays (low)
RELAY1_TRIS = 0;
RELAY2_TRIS = 0;
RELAY1 = 0;
RELAY2 = 0;
// Initialize SPI pins as inputs
SPICLK_TRIS = 1;
SPISDO_TRIS = 1;
SPI_CS_TRIS = 1;
SPISDI_TRIS = 1;
//TODO: Init unused pins as inputs
// Read the board ID
m_unBoardId = (DIO_PORT & DIO_MASK) ^ DIO_MASK;
// Read the parameters previously saved in flash
loadDataFromMemory();
//Enables the core to handle any pending interrupt requests
asm volatile ("ei");
}
/*************************************************************************
* This function is the entry point for KWMETIS
**************************************************************************/
void METIS_mCPartGraphKway(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy,
idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag,
int *nparts, floattype *rubvec, int *options, int *edgecut,
idxtype *part)
{
int i, j;
GraphType graph;
CtrlType ctrl;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
SetUpGraph(&graph, OP_KMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = McKMETIS_CTYPE;
ctrl.IType = McKMETIS_ITYPE;
ctrl.RType = McKMETIS_RTYPE;
ctrl.dbglvl = McKMETIS_DBGLVL;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
}
ctrl.optype = OP_KMETIS;
ctrl.CoarsenTo = amax((*nvtxs)/(20*log2Int(*nparts)), 30*(*nparts));
ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
InitRandom(-1);
AllocateWorkSpace(&ctrl, &graph, *nparts);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
ASSERT(CheckGraph(&graph));
*edgecut = MCMlevelKWayPartitioning(&ctrl, &graph, *nparts, part, rubvec);
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
FreeWorkSpace(&ctrl, &graph);
if (*numflag == 1)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
}
void main ()
{
// Initializing PIC16LF1827
InitPorts();
InitTimers();
InitInterrupts();
while(1)
{
}
}
/***********LED Blinky Example**********************************************************************/
int main()
{
LPC_GPIO0->FIODIR |= (1 << 22); // set P0.22 to output
LPC_GPIO0->FIOPIN &= ~(1 << 22); //and turn the LED off.
InitTimers(); //initialize the timer;
can_init(125000);
//CAN_Init(LPC_CAN2, 125000);
OLCB_NodeID *id = new OLCB_NodeID(1,2,3,4,5,6);
while(1)
{
LPC_GPIO0->FIOPIN ^= (1 << 22); // Toggle P1.29
delay(500);
}
return 0;
}
/*************************************************************************
* This function is the entry point for KWMETIS with seed specification
* in options[7]
**************************************************************************/
void METIS_WPartGraphKway2(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts,
float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part)
{
idxtype i, j;
GraphType graph;
CtrlType ctrl;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
SetUpGraph(&graph, OP_KMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = KMETIS_CTYPE;
ctrl.IType = KMETIS_ITYPE;
ctrl.RType = KMETIS_RTYPE;
ctrl.dbglvl = KMETIS_DBGLVL;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
}
ctrl.optype = OP_KMETIS;
ctrl.CoarsenTo = 20*(*nparts);
ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt, 1) : (*nvtxs))/ctrl.CoarsenTo);
InitRandom(options[7]);
AllocateWorkSpace(&ctrl, &graph, *nparts);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr));
*edgecut = MlevelKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03);
IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
FreeWorkSpace(&ctrl, &graph);
if (*numflag == 1)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
}
/*************************************************************************
* This function is the entry point for KWMETIS
**************************************************************************/
void METIS_WPartGraphVKway(int *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *vsize, int *wgtflag, int *numflag, int *nparts,
float *tpwgts, int *options, int *volume, idxtype *part)
{
int i, j;
GraphType graph;
CtrlType ctrl;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
VolSetUpGraph(&graph, OP_KVMETIS, *nvtxs, 1, xadj, adjncy, vwgt, vsize, *wgtflag);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = KVMETIS_CTYPE;
ctrl.IType = KVMETIS_ITYPE;
ctrl.RType = KVMETIS_RTYPE;
ctrl.dbglvl = KVMETIS_DBGLVL;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
}
ctrl.optype = OP_KVMETIS;
ctrl.CoarsenTo = amax((*nvtxs)/(40*log2Int(*nparts)), 20*(*nparts));
ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt) : (*nvtxs))/ctrl.CoarsenTo);
InitRandom(-1);
AllocateWorkSpace(&ctrl, &graph, *nparts);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
*volume = MlevelVolKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03);
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
FreeWorkSpace(&ctrl, &graph);
if (*numflag == 1)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
}
void ClassicLadder_InitAllDatas( void )
{
InitVars();
#ifdef OLD_TIMERS_MONOS_SUPPORT
InitTimers();
InitMonostables();
#endif
InitCounters();
InitTimersIEC();
InitArithmExpr();
InitRungs();
InitSections( );
#ifdef SEQUENTIAL_SUPPORT
InitSequential( );
#endif
InitSymbols( );
}
/***********************************************************************************
* This function creates the fused-element-graph and returns the partition
************************************************************************************/
void ParMETIS_FusedElementGraph(idxtype *vtxdist, idxtype *xadj, realtype *vvol,
realtype *vsurf, idxtype *adjncy, idxtype *vwgt, realtype *adjwgt,
int *wgtflag, int *numflag, int *nparts, int *options,
idxtype *part, MPI_Comm *comm)
{
int npes, mype, nvtxs;
CtrlType ctrl;
WorkSpaceType wspace;
GraphType *graph;
MPI_Comm_size(*comm, &npes);
MPI_Comm_rank(*comm, &mype);
nvtxs = vtxdist[mype+1]-vtxdist[mype];
/* IFSET(options[OPTION_DBGLVL], DBG_TRACK, printf("%d ParMETIS_FEG npes=%d\n",mype, npes)); */
SetUpCtrl(&ctrl, *nparts, options, *comm);
ctrl.CoarsenTo = amin(vtxdist[npes]+1, 25*amax(npes, *nparts));
graph = SetUpGraph(&ctrl, vtxdist, xadj, vwgt, adjncy, adjwgt, *wgtflag);
graph->where = part;
PreAllocateMemory(&ctrl, graph, &wspace);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
CreateFusedElementGraph(&ctrl, graph, &wspace, numflag);
idxcopy(nvtxs, graph->where, part);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
if (((*wgtflag)&2) == 0)
IMfree((void**)&graph->vwgt, LTERM);
IMfree((void**)&graph->lperm, &graph->peind, &graph->pexadj, &graph->peadjncy,
&graph->peadjloc, &graph->recvptr, &graph->recvind, &graph->sendptr,
&graph->imap, &graph->sendind, &graph, LTERM);
FreeWSpace(&wspace);
FreeCtrl(&ctrl);
}
void main()
{
InitSystemClock();
InitPortsIO();
InitTimers();
EnableInterrupts();
while (1)
{
if ((PINB&0x80)==0x80)
{
asm("BRES 0x5340,#0");
asm("BSET 0x525C,#4");
};
if ((PINB&0x80)==0x00)
{
asm("BSET 0x5340,#0");
};
}
}
extern "C" int __declspec(dllexport) Load( PLUGINLINK *link )
{
pluginLink = link;
mir_getMMI( &mmi );
mir_getUTFI( &utfi );
mir_getLI( &li );
AddIcons();
InitTimers();
InitServers();
InitContactMenus();
// register protocol
PROTOCOLDESCRIPTOR pd = { 0 };
pd.cbSize = sizeof( pd );
pd.szName = "IRC";
pd.type = PROTOTYPE_PROTOCOL;
pd.fnInit = ( pfnInitProto )ircProtoInit;
pd.fnUninit = ( pfnUninitProto )ircProtoUninit;
CallService( MS_PROTO_REGISTERMODULE, 0, (LPARAM)&pd );
return 0;
}
void CIA6526::DoInit() {
// initialize base class
Chip::DoInit();
// set function to call at each clock
SetOnClock((pfn)OnClock);
SetBusy();
// initialize components
Reset.Init("Reset", this);
Reset.SetOnHigh((pfn)OnReset);
Reset.SetOnLow((pfn)OnReset);
InitPorts();
InitTimers();
InitTOD();
InitSDR();
InitControl();
// reset components
OnReset();
};
//=========================================================================
//----- (00000C48) --------------------------------------------------------
__myevic__ void InitHardware()
{
SYS_UnlockReg();
// 32.768kHz external crystal
if ( dfStatus.x32off )
{
CLK_DisableXtalRC( CLK_PWRCTL_LXTEN_Msk );
}
else
{
SYS->GPF_MFPL &= ~(SYS_GPF_MFPL_PF0MFP_Msk|SYS_GPF_MFPL_PF1MFP_Msk);
SYS->GPF_MFPL |= (SYS_GPF_MFPL_PF0MFP_X32_OUT|SYS_GPF_MFPL_PF1MFP_X32_IN);
CLK_EnableXtalRC( CLK_PWRCTL_LXTEN_Msk );
CLK_WaitClockReady( CLK_STATUS_LXTSTB_Msk );
}
SetPWMClock();
SYS_LockReg();
#if (ENABLE_UART)
InitUART0();
#endif
InitGPIO();
if ( !PD3 )
{
gFlags.noclock = 1;
}
InitSPI0();
InitEADC();
InitPWM();
InitTimers();
InitUSB();
}
/*********************************************************************
* Function: main
*********************************************************************/
void main(void) {
u32 ResponseCount;
void *pExitCriticalArg;
u32 i; //loop variable
// initialize the EZ-Kit
ezInit(1);
// initialize the flag manager because the LEDs and buttons connect via flags
// Since callbacks are not being used memory does not to be given to the service
ezErrorCheck(adi_flag_Init(NULL, 0, &ResponseCount, NULL));
//***CODE SNIPPED****//
InitTimers();
while (1) {
//***CODE SNIPPED****//
}
} // END WHILE
int METIS_PartGraphKway(idx_t *nvtxs, idx_t *ncon, idx_t *xadj, idx_t *adjncy,
idx_t *vwgt, idx_t *vsize, idx_t *adjwgt, idx_t *nparts,
real_t *tpwgts, real_t *ubvec, idx_t *options, idx_t *objval,
idx_t *part)
{
int sigrval=0, renumber=0;
graph_t *graph;
ctrl_t *ctrl;
/* set up malloc cleaning code and signal catchers */
if (!gk_malloc_init())
return METIS_ERROR_MEMORY;
gk_sigtrap();
if ((sigrval = gk_sigcatch()) != 0)
goto SIGTHROW;
/* set up the run parameters */
ctrl = SetupCtrl(METIS_OP_KMETIS, options, *ncon, *nparts, tpwgts, ubvec);
if (!ctrl) {
gk_siguntrap();
return METIS_ERROR_INPUT;
}
/* if required, change the numbering to 0 */
if (ctrl->numflag == 1) {
Change2CNumbering(*nvtxs, xadj, adjncy);
renumber = 1;
}
/* set up the graph */
graph = SetupGraph(ctrl, *nvtxs, *ncon, xadj, adjncy, vwgt, vsize, adjwgt);
/* set up multipliers for making balance computations easier */
SetupKWayBalMultipliers(ctrl, graph);
/* set various run parameters that depend on the graph */
if (ctrl->iptype == METIS_IPTYPE_METISRB) {
ctrl->CoarsenTo = gk_max((*nvtxs)/(40*gk_log2(*nparts)), 30*(*nparts));
ctrl->CoarsenTo = 10*(*nparts);
ctrl->nIparts = (ctrl->CoarsenTo == 30*(*nparts) ? 4 : 5);
}
else {
ctrl->CoarsenTo = 10*(*nparts);
ctrl->nIparts = 10;
}
/* take care contiguity requests for disconnected graphs */
if (ctrl->contig && !IsConnected(graph, 0))
gk_errexit(SIGERR, "METIS Error: A contiguous partition is requested for a non-contiguous input graph.\n");
/* allocate workspace memory */
AllocateWorkSpace(ctrl, graph);
/* start the partitioning */
IFSET(ctrl->dbglvl, METIS_DBG_TIME, InitTimers(ctrl));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startwctimer(ctrl->TotalTmr));
*objval = MlevelKWayPartitioning(ctrl, graph, part);
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopwctimer(ctrl->TotalTmr));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, PrintTimers(ctrl));
/* clean up */
FreeCtrl(&ctrl);
SIGTHROW:
/* if required, change the numbering back to 1 */
if (renumber)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
gk_siguntrap();
gk_malloc_cleanup(0);
return metis_rcode(sigrval);
}
int METIS_NodeND(idx_t *nvtxs, idx_t *xadj, idx_t *adjncy, idx_t *vwgt,
idx_t *options, idx_t *perm, idx_t *iperm)
{
int sigrval=0, renumber=0;
idx_t i, ii, j, l, nnvtxs=0;
graph_t *graph=NULL;
ctrl_t *ctrl;
idx_t *cptr, *cind, *piperm;
int numflag = 0;
/* set up malloc cleaning code and signal catchers */
if (!gk_malloc_init())
return METIS_ERROR_MEMORY;
gk_sigtrap();
if ((sigrval = gk_sigcatch()) != 0)
goto SIGTHROW;
/* set up the run time parameters */
ctrl = SetupCtrl(METIS_OP_OMETIS, options, 1, 3, NULL, NULL);
if (!ctrl) {
gk_siguntrap();
return METIS_ERROR_INPUT;
}
/* if required, change the numbering to 0 */
if (ctrl->numflag == 1) {
Change2CNumbering(*nvtxs, xadj, adjncy);
renumber = 1;
}
IFSET(ctrl->dbglvl, METIS_DBG_TIME, InitTimers(ctrl));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_startcputimer(ctrl->TotalTmr));
/* prune the dense columns */
if (ctrl->pfactor > 0.0) {
piperm = imalloc(*nvtxs, "OMETIS: piperm");
graph = PruneGraph(ctrl, *nvtxs, xadj, adjncy, vwgt, piperm, ctrl->pfactor);
if (graph == NULL) {
/* if there was no prunning, cleanup the pfactor */
gk_free((void **)&piperm, LTERM);
ctrl->pfactor = 0.0;
}
else {
nnvtxs = graph->nvtxs;
ctrl->compress = 0; /* disable compression if prunning took place */
}
}
/* compress the graph; note that compression only happens if not prunning
has taken place. */
if (ctrl->compress) {
cptr = imalloc(*nvtxs+1, "OMETIS: cptr");
cind = imalloc(*nvtxs, "OMETIS: cind");
graph = CompressGraph(ctrl, *nvtxs, xadj, adjncy, vwgt, cptr, cind);
if (graph == NULL) {
/* if there was no compression, cleanup the compress flag */
gk_free((void **)&cptr, &cind, LTERM);
ctrl->compress = 0;
}
else {
nnvtxs = graph->nvtxs;
ctrl->cfactor = 1.0*(*nvtxs)/nnvtxs;
if (ctrl->cfactor > 1.5 && ctrl->nseps == 1)
ctrl->nseps = 2;
//ctrl->nseps = (idx_t)(ctrl->cfactor*ctrl->nseps);
}
}
/* if no prunning and no compression, setup the graph in the normal way. */
if (ctrl->pfactor == 0.0 && ctrl->compress == 0)
graph = SetupGraph(ctrl, *nvtxs, 1, xadj, adjncy, vwgt, NULL, NULL);
ASSERT(CheckGraph(graph, ctrl->numflag, 1));
/* allocate workspace memory */
AllocateWorkSpace(ctrl, graph);
/* do the nested dissection ordering */
if (ctrl->ccorder)
MlevelNestedDissectionCC(ctrl, graph, iperm, graph->nvtxs);
else
MlevelNestedDissection(ctrl, graph, iperm, graph->nvtxs);
if (ctrl->pfactor > 0.0) { /* Order any prunned vertices */
icopy(nnvtxs, iperm, perm); /* Use perm as an auxiliary array */
for (i=0; i<nnvtxs; i++)
iperm[piperm[i]] = perm[i];
for (i=nnvtxs; i<*nvtxs; i++)
iperm[piperm[i]] = i;
gk_free((void **)&piperm, LTERM);
}
else if (ctrl->compress) { /* Uncompress the ordering */
/* construct perm from iperm */
for (i=0; i<nnvtxs; i++)
perm[iperm[i]] = i;
for (l=ii=0; ii<nnvtxs; ii++) {
i = perm[ii];
for (j=cptr[i]; j<cptr[i+1]; j++)
iperm[cind[j]] = l++;
}
gk_free((void **)&cptr, &cind, LTERM);
}
for (i=0; i<*nvtxs; i++)
perm[iperm[i]] = i;
IFSET(ctrl->dbglvl, METIS_DBG_TIME, gk_stopcputimer(ctrl->TotalTmr));
IFSET(ctrl->dbglvl, METIS_DBG_TIME, PrintTimers(ctrl));
/* clean up */
FreeCtrl(&ctrl);
SIGTHROW:
/* if required, change the numbering back to 1 */
if (renumber)
Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
gk_siguntrap();
gk_malloc_cleanup(0);
return metis_rcode(sigrval);
}
//-------------------------------------------------------------------
//----------------------------Code-----------------------------------
//-------------------------------------------------------------------
void main(void)
{
// should only execute main loop once; after this just respond to interrupts
InitTimers();
InitPorts();
InitComm();
InitInterrupts();
SSPBUF = BytesOut[i];
while(1)
{
//-----------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------
//-----EUART STUFF-------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------
if(CommActive)
{
if( X_Transition!=0 )
{
X_Transition = 0;
switch( CurrentX_State )
{
case X_Idle_State :
{
SEND = 1;
NextX_State = X_StartDelim_State;
NextByteOut = 0x7E;
// Starting Edit for Variable Message Size
MessageCounter = Encode_Message(CurrentType);
X_LengthLSB = MessageCounter + 5; //For framing bytes
// Populating the Message Frame
X_CMD = TXData[0];
X_RF1 = TXData[1];
X_RF2 = TXData[2];
X_RF3 = TXData[3];
X_RF4 = TXData[4];
X_RF5 = TXData[5];
}
break;
case X_StartDelim_State :
{
NextX_State = X_LengthMSB_State;
NextByteOut = X_LengthMSB ;
}
break;
case X_LengthMSB_State :
{
NextX_State = X_LengthLSB_State;
NextByteOut = X_LengthLSB;
}
break;
case X_LengthLSB_State :
{
NextX_State = X_API_State;
NextByteOut = X_API;
}
break;
case X_API_State :
{
NextX_State = X_FID_State;
NextByteOut = X_FID;
}
break;
case X_FID_State :
{
NextX_State = X_AddrMSB_State;
NextByteOut = X_AddrMSB;
}
break;
case X_AddrMSB_State :
{
NextX_State = X_AddrLSB_State;
NextByteOut = X_AddrLSB;
}
break;
case X_AddrLSB_State :
{
NextX_State = X_Options_State;
NextByteOut = X_Options;
}
break;
case X_Options_State :
{
NextX_State = X_CMD_State; // will later need logic here for what transition to do based on length LSB
NextByteOut = X_CMD;
}
break;
case X_CMD_State :
{
MessageCounter--;
if(MessageCounter)
{
NextX_State = X_RF1_State;
NextByteOut = X_RF1;
}
else
{
NextX_State = X_Checksum_State;
NextByteOut = CalculateChecksum();
}
}
break;
case X_RF1_State :
{
MessageCounter--;
if(MessageCounter)
{
NextX_State = X_RF2_State;
NextByteOut = X_RF2;
}
else
{
NextX_State = X_Checksum_State;
NextByteOut = CalculateChecksum();
}
}
break;
case X_RF2_State :
{
MessageCounter--;
if(MessageCounter)
{
NextX_State = X_RF3_State;
NextByteOut = X_RF3;
}
else
{
NextX_State = X_Checksum_State;
NextByteOut = CalculateChecksum();
}
}
break;
case X_RF3_State :
{
MessageCounter--;
if(MessageCounter)
{
NextX_State = X_RF4_State;
NextByteOut = X_RF4;
}
else
{
NextX_State = X_Checksum_State;
NextByteOut = CalculateChecksum();
}
}
break;
case X_RF4_State :
{
MessageCounter--;
if(MessageCounter)
{
NextX_State = X_RF5_State;
NextByteOut = X_RF5;
}
else
{
NextX_State = X_Checksum_State;
NextByteOut = CalculateChecksum();
}
}
break;
case X_RF5_State :
{
NextX_State = X_Checksum_State;
NextByteOut = CalculateChecksum();
}
break;
case X_Checksum_State :
{
SEND = 0;
NextX_State = X_Idle_State;
NextByteOut = 0x7E;
}
break;
} // end switch case
}// end if X_Transition
if( R_Transition!=0 )
{
R_Transition = 0;
switch( CurrentR_State )
{
case R_Idle_State :
{
if (ByteIn == 0x7E) // should always be this!
{ NextR_State = R_LengthMSB_State; }
}
break;
case R_LengthMSB_State :
{
if ( ByteIn == 0x00 ) // should always be this!
{ NextR_State = R_LengthLSB_State; }
}
break;
case R_LengthLSB_State :
{
NextR_State = R_API_State;
R_LengthLSB = ByteIn;
}
break;
case R_API_State :
{
///Adding Code to Handle different types of received messages
R_API = ByteIn;
if (R_API == API_TXSTAT)
NextR_State = R_FID_State;
else if (R_API == API_RXPACK)
{
NextR_State = R_AddrMSB_State;
LostCommCounter = 0;
}
else
NextR_State = R_Idle_State;
}
break;
case R_AddrMSB_State :
{
NextR_State = R_AddrLSB_State;
R_AddrMSB = ByteIn;
}
break;
case R_AddrLSB_State :
{
NextR_State =R_SigStr_State;
R_AddrLSB = ByteIn;
}
break;
case R_SigStr_State :
{
NextR_State = R_Options_State;
R_SigStr = ByteIn;
}
break;
case R_Options_State :
{
NextR_State = R_CMD_State; // will later need logic here for what transition to do based on length LSB
R_Options = ByteIn;
}
break;
case R_CMD_State:
{
NextR_State = R_RF1_State;
R_CMD = ByteIn;
}
break;
case R_RF1_State :
{
NextR_State = R_Idle_State;
R_RF1 = ByteIn;
if (R_CMD == 0x05)
{ //PAIR_RESP Received
if(R_RF1&BIT0HI)
{
Paired = 1;
//Stop Broadcasting and send Direct Messages
X_AddrMSB = R_AddrMSB;
X_AddrLSB = R_AddrLSB;
CurrentType = CTRL;
Set_PAIRED;
PORTC = PORTC_Copy;
LostCommCounter = 0;
}
else
{
XBee_State(0);
}
}
if (R_CMD == 0x06)
{ //STATUS Received
Process_Status(R_RF1);
}
}
break;
case R_FID_State :
{
NextR_State = R_STATUS_State;
R_FID = ByteIn;
}
break;
case R_STATUS_State :
{
NextR_State = R_Idle_State;
R_STATUS = ByteIn;
//Code to Resend Message if no ACK
if (R_STATUS)
{
X_Transition = 1;
CurrentX_State = X_Idle_State;
NextX_State = CurrentX_State;
}
}
break;
} // end switch case
}// end if R_Transition
if (SEND && TXIF) // for some reason, with TXIE I get 0x7E transmitted twice.
{
X_Transition = 1;
TXREG = NextByteOut;
}
CurrentX_State = NextX_State;
CurrentR_State = NextR_State;
}
}
}; // end main
/*************************************************************************
* This function is the entry point for the node ND code for ParMETIS
**************************************************************************/
void METIS_NodeNDP(int nvtxs, idxtype *xadj, idxtype *adjncy, int npes,
int *options, idxtype *perm, idxtype *iperm, idxtype *sizes)
{
int i, ii, j, l, wflag, nflag;
GraphType graph;
CtrlType ctrl;
idxtype *cptr, *cind;
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = ONMETIS_CTYPE;
ctrl.IType = ONMETIS_ITYPE;
ctrl.RType = ONMETIS_RTYPE;
ctrl.dbglvl = ONMETIS_DBGLVL;
ctrl.oflags = ONMETIS_OFLAGS;
ctrl.pfactor = ONMETIS_PFACTOR;
ctrl.nseps = ONMETIS_NSEPS;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
ctrl.oflags = options[OPTION_OFLAGS];
ctrl.pfactor = options[OPTION_PFACTOR];
ctrl.nseps = options[OPTION_NSEPS];
}
if (ctrl.nseps < 1)
ctrl.nseps = 1;
ctrl.optype = OP_ONMETIS;
ctrl.CoarsenTo = 100;
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
InitRandom(-1);
if (ctrl.oflags&OFLAG_COMPRESS) {
/*============================================================
* Compress the graph
==============================================================*/
cptr = idxmalloc(nvtxs+1, "ONMETIS: cptr");
cind = idxmalloc(nvtxs, "ONMETIS: cind");
CompressGraph(&ctrl, &graph, nvtxs, xadj, adjncy, cptr, cind);
if (graph.nvtxs >= COMPRESSION_FRACTION*(nvtxs)) {
ctrl.oflags--; /* We actually performed no compression */
GKfree((void**)&cptr, &cind, LTERM);
}
else if (2*graph.nvtxs < nvtxs && ctrl.nseps == 1)
ctrl.nseps = 2;
}
else {
SetUpGraph(&graph, OP_ONMETIS, nvtxs, 1, xadj, adjncy, NULL, NULL, 0);
}
/*=============================================================
* Do the nested dissection ordering
--=============================================================*/
ctrl.maxvwgt = 1.5*(idxsum(graph.nvtxs, graph.vwgt)/ctrl.CoarsenTo);
AllocateWorkSpace(&ctrl, &graph, 2);
idxset(2*npes-1, 0, sizes);
MlevelNestedDissectionP(&ctrl, &graph, iperm, graph.nvtxs, npes, 0, sizes);
FreeWorkSpace(&ctrl, &graph);
if (ctrl.oflags&OFLAG_COMPRESS) { /* Uncompress the ordering */
if (graph.nvtxs < COMPRESSION_FRACTION*(nvtxs)) {
/* construct perm from iperm */
for (i=0; i<graph.nvtxs; i++)
perm[iperm[i]] = i;
for (l=ii=0; ii<graph.nvtxs; ii++) {
i = perm[ii];
for (j=cptr[i]; j<cptr[i+1]; j++)
iperm[cind[j]] = l++;
}
}
GKfree((void**)&cptr, &cind, LTERM);
}
for (i=0; i<nvtxs; i++)
perm[iperm[i]] = i;
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
}
/*************************************************************************
* This function is the entry point for PWMETIS that accepts exact weights
* for the target partitions
**************************************************************************/
void METIS_mCPartGraphRecursive2(int *nvtxs, int *ncon, idxtype *xadj, idxtype *adjncy,
idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *nparts,
float *tpwgts, int *options, int *edgecut, idxtype *part)
{
int i, j;
GraphType graph;
CtrlType ctrl;
float *mytpwgts;
float avgwgt;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
SetUpGraph(&graph, OP_PMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag);
graph.npwgts = NULL;
mytpwgts = fmalloc(*nparts, "mytpwgts");
scopy(*nparts, tpwgts, mytpwgts);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = McPMETIS_CTYPE;
ctrl.IType = McPMETIS_ITYPE;
ctrl.RType = McPMETIS_RTYPE;
ctrl.dbglvl = McPMETIS_DBGLVL;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
}
ctrl.optype = OP_PMETIS;
ctrl.CoarsenTo = 100;
ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo);
InitRandom(options[7]);
AllocateWorkSpace(&ctrl, &graph, *nparts);
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
ASSERT(CheckGraph(&graph));
*edgecut = MCMlevelRecursiveBisection2(&ctrl, &graph, *nparts, mytpwgts, part, 1.000, 0);
/*
{
idxtype wgt[2048], minwgt, maxwgt, sumwgt;
printf("nvtxs: %d, nparts: %d, ncon: %d\n", graph.nvtxs, *nparts, *ncon);
for (i=0; i<(*nparts)*(*ncon); i++)
wgt[i] = 0;
for (i=0; i<graph.nvtxs; i++)
for (j=0; j<*ncon; j++)
wgt[part[i]*(*ncon)+j] += vwgt[i*(*ncon)+j];
for (j=0; j<*ncon; j++) {
minwgt = maxwgt = sumwgt = 0;
for (i=0; i<(*nparts); i++) {
minwgt = (wgt[i*(*ncon)+j] < wgt[minwgt*(*ncon)+j]) ? i : minwgt;
maxwgt = (wgt[i*(*ncon)+j] > wgt[maxwgt*(*ncon)+j]) ? i : maxwgt;
sumwgt += wgt[i*(*ncon)+j];
}
avgwgt = (float)sumwgt / (float)*nparts;
printf("min: %5d, max: %5d, avg: %5.2f, balance: %6.3f\n", wgt[minwgt*(*ncon)+j], wgt[maxwgt*(*ncon)+j], avgwgt, (float)wgt[maxwgt*(*ncon)+j] / avgwgt);
}
printf("\n");
}
*/
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
FreeWorkSpace(&ctrl, &graph);
GKfree((void**)(void *)&mytpwgts, LTERM);
if (*numflag == 1)
Change2FNumbering(*nvtxs, xadj, adjncy, part);
}
/***********************************************************************************
* This function is the entry point of the parallel ordering algorithm.
* This function assumes that the graph is already nice partitioned among the
* processors and then proceeds to perform recursive bisection.
************************************************************************************/
void ParMETIS_V3_NodeND(idxtype *vtxdist, idxtype *xadj, idxtype *adjncy, int *numflag,
int *options, idxtype *order, idxtype *sizes, MPI_Comm *comm)
{
int i, j;
int ltvwgts[MAXNCON];
int nparts, npes, mype, wgtflag = 0, seed = GLOBAL_SEED;
CtrlType ctrl;
WorkSpaceType wspace;
GraphType *graph, *mgraph;
idxtype *morder;
int minnvtxs;
MPI_Comm_size(*comm, &npes);
MPI_Comm_rank(*comm, &mype);
nparts = npes;
if (!ispow2(npes)) {
if (mype == 0)
printf("Error: The number of processors must be a power of 2!\n");
return;
}
if (vtxdist[npes] < (int)((float)(npes*npes)*1.2)) {
if (mype == 0)
printf("Error: Too many processors for this many vertices.\n");
return;
}
minnvtxs = vtxdist[1]-vtxdist[0];
for (i=0; i<npes; i++)
minnvtxs = (minnvtxs < vtxdist[i+1]-vtxdist[i]) ? minnvtxs : vtxdist[i+1]-vtxdist[i];
if (minnvtxs < (int)((float)npes*1.1)) {
if (mype == 0)
printf("Error: vertices are not distributed equally.\n");
return;
}
if (*numflag == 1)
ChangeNumbering(vtxdist, xadj, adjncy, order, npes, mype, 1);
SetUpCtrl(&ctrl, nparts, options[PMV3_OPTION_DBGLVL], *comm);
ctrl.CoarsenTo = amin(vtxdist[npes]+1, 25*npes);
ctrl.CoarsenTo = amin(vtxdist[npes]+1, 25*amax(npes, nparts));
ctrl.seed = mype;
ctrl.sync = seed;
ctrl.partType = STATIC_PARTITION;
ctrl.ps_relation = -1;
ctrl.tpwgts = fsmalloc(nparts, 1.0/(float)(nparts), "tpwgts");
ctrl.ubvec[0] = 1.03;
graph = Moc_SetUpGraph(&ctrl, 1, vtxdist, xadj, NULL, adjncy, NULL, &wgtflag);
PreAllocateMemory(&ctrl, graph, &wspace);
/*=======================================================
* Compute the initial k-way partitioning
=======================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
Moc_Global_Partition(&ctrl, graph, &wspace);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimingInfo(&ctrl));
/*=======================================================
* Move the graph according to the partitioning
=======================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.MoveTmr));
MALLOC_CHECK(NULL);
graph->ncon = 1;
mgraph = Moc_MoveGraph(&ctrl, graph, &wspace);
MALLOC_CHECK(NULL);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.MoveTmr));
/*=======================================================
* Now compute an ordering of the moved graph
=======================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
FreeWSpace(&wspace);
PreAllocateMemory(&ctrl, mgraph, &wspace);
ctrl.ipart = ISEP_NODE;
ctrl.CoarsenTo = amin(vtxdist[npes]+1, amax(20*npes, 1000));
/* compute tvwgts */
for (j=0; j<mgraph->ncon; j++)
ltvwgts[j] = 0;
for (i=0; i<mgraph->nvtxs; i++)
for (j=0; j<mgraph->ncon; j++)
ltvwgts[j] += mgraph->vwgt[i*mgraph->ncon+j];
for (j=0; j<mgraph->ncon; j++)
ctrl.tvwgts[j] = GlobalSESum(&ctrl, ltvwgts[j]);
mgraph->nvwgt = fmalloc(mgraph->nvtxs*mgraph->ncon, "mgraph->nvwgt");
for (i=0; i<mgraph->nvtxs; i++)
for (j=0; j<mgraph->ncon; j++)
mgraph->nvwgt[i*mgraph->ncon+j] = (float)(mgraph->vwgt[i*mgraph->ncon+j]) / (float)(ctrl.tvwgts[j]);
morder = idxmalloc(mgraph->nvtxs, "PAROMETIS: morder");
MultilevelOrder(&ctrl, mgraph, morder, sizes, &wspace);
MALLOC_CHECK(NULL);
/* Invert the ordering back to the original graph */
ProjectInfoBack(&ctrl, graph, order, morder, &wspace);
MALLOC_CHECK(NULL);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimingInfo(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
free(ctrl.tpwgts);
free(morder);
FreeGraph(mgraph);
FreeInitialGraphAndRemap(graph, 0);
FreeWSpace(&wspace);
FreeCtrl(&ctrl);
if (*numflag == 1)
ChangeNumbering(vtxdist, xadj, adjncy, order, npes, mype, 0);
MALLOC_CHECK(NULL);
}
int main(void)
{
//STATIC_ASSERT(sizeof(uint16_t) == 2);
InitGPIO();
InitSPI_soft();
InitI2C_soft();
InitADC();
InitSystemTimer();
InitTimers();
InitMessages();
InitCC2500(preferredSettings); //(const uint8_t **)conf(+6bytes of code), preferredSettings
uart0_init( UART_BAUD_SELECT(RS485_BAUDRATE, F_CPU) );
//_delay_ms(5000);
//InitEXTI();
//MCUCR |= (_BV(ISC11) | _BV(ISC01));
/*check Watchdog reset flag*/
if(bit_is_set(MCUCSR, WDRF)) {
//increase wathcdog reset counter and save in eeprom
}
set_sleep_mode(SLEEP_MODE_IDLE); //варианты SLEEP_MODE_PWR_SAVE SLEEP_MODE_IDLE SLEEP_MODE_ADC
//wdt_enable(WDTO_2S);
sei(); //enable interrupts
for (uint8_t i = 0; i<0x05; i++) {
//_spi_start();
//spi_TxRx(0x9D);
//_spi_stop();
_delay_ms(100);
PORTC |= _BV(PC2); //blink for test
_delay_ms(100);
PORTC &= ~_BV(PC2);
_delay_ms(100);
RS485_DE_HIGH;
uart0_putc(0xba);
_delay_ms(2);
RS485_DE_LOW;
}
RS485_DE_LOW;
while(1) {
cc_table_state[CC_state]();
ProcessTimers(&sys_timer);
ProcessMessages();
wdt_reset();
/*enter in sleep mode until interrupts occured*/
// cli(); //disable interrupts
// if (some_condition)
// {
// sleep_enable();
// sei();
// sleep_cpu();
// sleep_disable();
// }
// sei();
}
return 0;
}
/***********************************************************************************
* This function is the entry point of the parallel multilevel local diffusion
* algorithm. It uses parallel undirected diffusion followed by adaptive k-way
* refinement. This function utilizes local coarsening.
************************************************************************************/
void ParMETIS_V3_RefineKway(idxtype *vtxdist, idxtype *xadj, idxtype *adjncy,
idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *ncon,
int *nparts, float *tpwgts, float *ubvec, int *options, int *edgecut,
idxtype *part, MPI_Comm *comm)
{
int h, i;
int npes, mype;
CtrlType ctrl;
WorkSpaceType wspace;
GraphType *graph;
int tewgt, tvsize, nmoved, maxin, maxout;
float gtewgt, gtvsize, avg, maximb;
int ps_relation, seed, dbglvl = 0;
int iwgtflag, inumflag, incon, inparts, ioptions[10];
float *itpwgts, iubvec[MAXNCON];
MPI_Comm_size(*comm, &npes);
MPI_Comm_rank(*comm, &mype);
/********************************/
/* Try and take care bad inputs */
/********************************/
if (options != NULL && options[0] == 1)
dbglvl = options[PMV3_OPTION_DBGLVL];
CheckInputs(REFINE_PARTITION, npes, dbglvl, wgtflag, &iwgtflag, numflag, &inumflag,
ncon, &incon, nparts, &inparts, tpwgts, &itpwgts, ubvec, iubvec,
NULL, NULL, options, ioptions, part, comm);
/* ADD: take care of disconnected graph */
/* ADD: take care of highly unbalanced vtxdist */
/*********************************/
/* Take care the nparts = 1 case */
/*********************************/
if (inparts <= 1) {
idxset(vtxdist[mype+1]-vtxdist[mype], 0, part);
*edgecut = 0;
return;
}
/**************************/
/* Set up data structures */
/**************************/
if (inumflag == 1)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 1);
/*****************************/
/* Set up control structures */
/*****************************/
if (ioptions[0] == 1) {
dbglvl = ioptions[PMV3_OPTION_DBGLVL];
seed = ioptions[PMV3_OPTION_SEED];
ps_relation = (npes == inparts) ? ioptions[PMV3_OPTION_PSR] : DISCOUPLED;
}
else {
dbglvl = GLOBAL_DBGLVL;
seed = GLOBAL_SEED;
ps_relation = (npes == inparts) ? COUPLED : DISCOUPLED;
}
SetUpCtrl(&ctrl, inparts, dbglvl, *comm);
ctrl.CoarsenTo = amin(vtxdist[npes]+1, 50*incon*amax(npes, inparts));
ctrl.ipc_factor = 1000.0;
ctrl.redist_factor = 1.0;
ctrl.redist_base = 1.0;
ctrl.seed = (seed == 0) ? mype : seed*mype;
ctrl.sync = GlobalSEMax(&ctrl, seed);
ctrl.partType = REFINE_PARTITION;
ctrl.ps_relation = ps_relation;
ctrl.tpwgts = itpwgts;
graph = Moc_SetUpGraph(&ctrl, incon, vtxdist, xadj, vwgt, adjncy, adjwgt, &iwgtflag);
graph->vsize = idxsmalloc(graph->nvtxs, 1, "vsize");
graph->home = idxmalloc(graph->nvtxs, "home");
if (ctrl.ps_relation == COUPLED)
idxset(graph->nvtxs, mype, graph->home);
else
idxcopy(graph->nvtxs, part, graph->home);
tewgt = idxsum(graph->nedges, graph->adjwgt);
tvsize = idxsum(graph->nvtxs, graph->vsize);
gtewgt = (float) GlobalSESum(&ctrl, tewgt) + 1.0/graph->gnvtxs;
gtvsize = (float) GlobalSESum(&ctrl, tvsize) + 1.0/graph->gnvtxs;
ctrl.edge_size_ratio = gtewgt/gtvsize;
scopy(incon, iubvec, ctrl.ubvec);
PreAllocateMemory(&ctrl, graph, &wspace);
/***********************/
/* Partition and Remap */
/***********************/
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
Adaptive_Partition(&ctrl, graph, &wspace);
ParallelReMapGraph(&ctrl, graph, &wspace);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
idxcopy(graph->nvtxs, graph->where, part);
if (edgecut != NULL)
*edgecut = graph->mincut;
/***********************/
/* Take care of output */
/***********************/
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimingInfo(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
if (ctrl.dbglvl&DBG_INFO) {
Mc_ComputeMoveStatistics(&ctrl, graph, &nmoved, &maxin, &maxout);
rprintf(&ctrl, "Final %3d-way Cut: %6d \tBalance: ", inparts, graph->mincut);
avg = 0.0;
for (h=0; h<incon; h++) {
maximb = 0.0;
for (i=0; i<inparts; i++)
maximb = amax(maximb, graph->gnpwgts[i*incon+h]/itpwgts[i*incon+h]);
avg += maximb;
rprintf(&ctrl, "%.3f ", maximb);
}
rprintf(&ctrl, "\nNMoved: %d %d %d %d\n", nmoved, maxin, maxout, maxin+maxout);
}
/*************************************/
/* Free memory, renumber, and return */
/*************************************/
GKfree((void **)&graph->lnpwgts, (void **)&graph->gnpwgts, (void **)&graph->nvwgt, (void **)(&graph->home), (void **)(&graph->vsize), LTERM);
GKfree((void **)&itpwgts, LTERM);
FreeInitialGraphAndRemap(graph, iwgtflag);
FreeWSpace(&wspace);
FreeCtrl(&ctrl);
if (inumflag == 1)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 0);
return;
}
/***********************************************************************************
* This function is the entry point of the parallel kmetis algorithm that uses
* coordinates to compute an initial graph distribution.
************************************************************************************/
void ParMETIS_V3_PartGeomKway(idxtype *vtxdist, idxtype *xadj, idxtype *adjncy,
idxtype *vwgt, idxtype *adjwgt, int *wgtflag, int *numflag, int *ndims,
float *xyz, int *ncon, int *nparts, float *tpwgts, float *ubvec,
int *options, int *edgecut, idxtype *part, MPI_Comm *comm)
{
int h, i, j;
int nvtxs = -1, npes, mype;
int uwgtflag, cut, gcut, maxnvtxs;
int ltvwgts[MAXNCON];
int moptions[10];
CtrlType ctrl;
idxtype *uvwgt;
WorkSpaceType wspace;
GraphType *graph, *mgraph;
float avg, maximb, balance, *mytpwgts;
int seed, dbglvl = 0;
int iwgtflag, inumflag, incon, inparts, ioptions[10];
float *itpwgts, iubvec[MAXNCON];
MPI_Comm_size(*comm, &npes);
MPI_Comm_rank(*comm, &mype);
/********************************/
/* Try and take care bad inputs */
/********************************/
if (options != NULL && options[0] == 1)
dbglvl = options[PMV3_OPTION_DBGLVL];
CheckInputs(STATIC_PARTITION, npes, dbglvl, wgtflag, &iwgtflag, numflag, &inumflag,
ncon, &incon, nparts, &inparts, tpwgts, &itpwgts, ubvec, iubvec,
NULL, NULL, options, ioptions, part, comm);
/*********************************/
/* Take care the nparts = 1 case */
/*********************************/
if (inparts <= 1) {
idxset(vtxdist[mype+1]-vtxdist[mype], 0, part);
*edgecut = 0;
return;
}
/******************************/
/* Take care of npes = 1 case */
/******************************/
if (npes == 1 && inparts > 1) {
moptions[0] = 0;
nvtxs = vtxdist[1];
if (incon == 1) {
METIS_WPartGraphKway(&nvtxs, xadj, adjncy, vwgt, adjwgt, &iwgtflag, &inumflag,
&inparts, itpwgts, moptions, edgecut, part);
}
else {
/* ADD: this is because METIS does not support tpwgts for all constraints */
mytpwgts = fmalloc(inparts, "mytpwgts");
for (i=0; i<inparts; i++)
mytpwgts[i] = itpwgts[i*incon];
moptions[7] = -1;
METIS_mCPartGraphRecursive2(&nvtxs, &incon, xadj, adjncy, vwgt, adjwgt, &iwgtflag,
&inumflag, &inparts, mytpwgts, moptions, edgecut, part);
free(mytpwgts);
}
return;
}
if (inumflag == 1)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 1);
/*****************************/
/* Set up control structures */
/*****************************/
if (ioptions[0] == 1) {
dbglvl = ioptions[PMV3_OPTION_DBGLVL];
seed = ioptions[PMV3_OPTION_SEED];
}
else {
dbglvl = GLOBAL_DBGLVL;
seed = GLOBAL_SEED;
}
SetUpCtrl(&ctrl, npes, dbglvl, *comm);
ctrl.CoarsenTo = amin(vtxdist[npes]+1, 25*incon*amax(npes, inparts));
ctrl.seed = (seed == 0) ? mype : seed*mype;
ctrl.sync = GlobalSEMax(&ctrl, seed);
ctrl.partType = STATIC_PARTITION;
ctrl.ps_relation = -1;
ctrl.tpwgts = itpwgts;
scopy(incon, iubvec, ctrl.ubvec);
uwgtflag = iwgtflag|2;
uvwgt = idxsmalloc(vtxdist[mype+1]-vtxdist[mype], 1, "uvwgt");
graph = Moc_SetUpGraph(&ctrl, 1, vtxdist, xadj, uvwgt, adjncy, adjwgt, &uwgtflag);
free(graph->nvwgt); graph->nvwgt = NULL;
PreAllocateMemory(&ctrl, graph, &wspace);
/*=================================================================
* Compute the initial npes-way partitioning geometric partitioning
=================================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
Coordinate_Partition(&ctrl, graph, *ndims, xyz, 1, &wspace);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimingInfo(&ctrl));
/*=================================================================
* Move the graph according to the partitioning
=================================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.MoveTmr));
free(uvwgt);
graph->vwgt = ((iwgtflag&2) != 0) ? vwgt : idxsmalloc(graph->nvtxs*incon, 1, "vwgt");
graph->ncon = incon;
j = ctrl.nparts;
ctrl.nparts = ctrl.npes;
mgraph = Moc_MoveGraph(&ctrl, graph, &wspace);
ctrl.nparts = j;
/**********************************************************/
/* Do the same functionality as Moc_SetUpGraph for mgraph */
/**********************************************************/
/* compute tvwgts */
for (j=0; j<incon; j++)
ltvwgts[j] = 0;
for (i=0; i<graph->nvtxs; i++)
for (j=0; j<incon; j++)
ltvwgts[j] += mgraph->vwgt[i*incon+j];
for (j=0; j<incon; j++)
ctrl.tvwgts[j] = GlobalSESum(&ctrl, ltvwgts[j]);
/* check for zero wgt constraints */
for (i=0; i<incon; i++) {
/* ADD: take care of the case in which tvwgts is zero */
if (ctrl.tvwgts[i] == 0) {
if (ctrl.mype == 0) printf("ERROR: sum weight for constraint %d is zero\n", i);
MPI_Finalize();
exit(-1);
}
}
/* compute nvwgt */
mgraph->nvwgt = fmalloc(mgraph->nvtxs*incon, "mgraph->nvwgt");
for (i=0; i<mgraph->nvtxs; i++)
for (j=0; j<incon; j++)
mgraph->nvwgt[i*incon+j] = (float)(mgraph->vwgt[i*incon+j]) / (float)(ctrl.tvwgts[j]);
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.MoveTmr));
if (ctrl.dbglvl&DBG_INFO) {
cut = 0;
for (i=0; i<graph->nvtxs; i++)
for (j=graph->xadj[i]; j<graph->xadj[i+1]; j++)
if (graph->where[i] != graph->where[graph->adjncy[j]])
cut += graph->adjwgt[j];
gcut = GlobalSESum(&ctrl, cut)/2;
maxnvtxs = GlobalSEMax(&ctrl, mgraph->nvtxs);
balance = (float)(maxnvtxs)/((float)(graph->gnvtxs)/(float)(npes));
rprintf(&ctrl, "XYZ Cut: %6d \tBalance: %6.3f [%d %d %d]\n",
gcut, balance, maxnvtxs, graph->gnvtxs, npes);
}
/*=================================================================
* Set up the newly moved graph
=================================================================*/
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
ctrl.nparts = inparts;
FreeWSpace(&wspace);
PreAllocateMemory(&ctrl, mgraph, &wspace);
/*=======================================================
* Now compute the partition of the moved graph
=======================================================*/
if (vtxdist[npes] < SMALLGRAPH || vtxdist[npes] < npes*20 || GlobalSESum(&ctrl, mgraph->nedges) == 0) {
IFSET(ctrl.dbglvl, DBG_INFO, rprintf(&ctrl, "Partitioning a graph of size %d serially\n", vtxdist[npes]));
PartitionSmallGraph(&ctrl, mgraph, &wspace);
}
else {
Moc_Global_Partition(&ctrl, mgraph, &wspace);
}
ParallelReMapGraph(&ctrl, mgraph, &wspace);
/* Invert the ordering back to the original graph */
ctrl.nparts = npes;
ProjectInfoBack(&ctrl, graph, part, mgraph->where, &wspace);
*edgecut = mgraph->mincut;
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
/*******************/
/* Print out stats */
/*******************/
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimingInfo(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, MPI_Barrier(ctrl.gcomm));
if (ctrl.dbglvl&DBG_INFO) {
rprintf(&ctrl, "Final %d-way CUT: %6d \tBalance: ", inparts, mgraph->mincut);
avg = 0.0;
for (h=0; h<incon; h++) {
maximb = 0.0;
for (i=0; i<inparts; i++)
maximb = amax(maximb, mgraph->gnpwgts[i*incon+h]/itpwgts[i*incon+h]);
avg += maximb;
rprintf(&ctrl, "%.3f ", maximb);
}
rprintf(&ctrl, " avg: %.3f\n", avg/(float)incon);
}
GKfree((void **)&itpwgts, LTERM);
FreeGraph(mgraph);
FreeInitialGraphAndRemap(graph, iwgtflag);
FreeWSpace(&wspace);
FreeCtrl(&ctrl);
if (inumflag == 1)
ChangeNumbering(vtxdist, xadj, adjncy, part, npes, mype, 0);
}
/*************************************************************************
* This function is the entry point for ONCMETIS
**************************************************************************/
void METIS_NodeND(int *nvtxs, idxtype *xadj, idxtype *adjncy, int *numflag, int *options,
idxtype *perm, idxtype *iperm)
{
int i, ii, j, l, wflag, nflag;
GraphType graph;
CtrlType ctrl;
idxtype *cptr, *cind, *piperm;
if (*numflag == 1)
Change2CNumbering(*nvtxs, xadj, adjncy);
if (options[0] == 0) { /* Use the default parameters */
ctrl.CType = ONMETIS_CTYPE;
ctrl.IType = ONMETIS_ITYPE;
ctrl.RType = ONMETIS_RTYPE;
ctrl.dbglvl = ONMETIS_DBGLVL;
ctrl.oflags = ONMETIS_OFLAGS;
ctrl.pfactor = ONMETIS_PFACTOR;
ctrl.nseps = ONMETIS_NSEPS;
}
else {
ctrl.CType = options[OPTION_CTYPE];
ctrl.IType = options[OPTION_ITYPE];
ctrl.RType = options[OPTION_RTYPE];
ctrl.dbglvl = options[OPTION_DBGLVL];
ctrl.oflags = options[OPTION_OFLAGS];
ctrl.pfactor = options[OPTION_PFACTOR];
ctrl.nseps = options[OPTION_NSEPS];
}
if (ctrl.nseps < 1)
ctrl.nseps = 1;
ctrl.optype = OP_ONMETIS;
ctrl.CoarsenTo = 100;
IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl));
IFSET(ctrl.dbglvl, DBG_TIME, starttimer(ctrl.TotalTmr));
InitRandom(-1);
if (ctrl.pfactor > 0) {
/*============================================================
* Prune the dense columns
==============================================================*/
piperm = idxmalloc(*nvtxs, "ONMETIS: piperm");
PruneGraph(&ctrl, &graph, *nvtxs, xadj, adjncy, piperm, (float)(0.1*ctrl.pfactor));
}
else if (ctrl.oflags&OFLAG_COMPRESS) {
/*============================================================
* Compress the graph
==============================================================*/
cptr = idxmalloc(*nvtxs+1, "ONMETIS: cptr");
cind = idxmalloc(*nvtxs, "ONMETIS: cind");
CompressGraph(&ctrl, &graph, *nvtxs, xadj, adjncy, cptr, cind);
if (graph.nvtxs >= COMPRESSION_FRACTION*(*nvtxs)) {
ctrl.oflags--; /* We actually performed no compression */
GKfree(&cptr, &cind, LTERM);
}
else if (2*graph.nvtxs < *nvtxs && ctrl.nseps == 1)
ctrl.nseps = 2;
}
else {
SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, NULL, NULL, 0);
}
/*=============================================================
* Do the nested dissection ordering
--=============================================================*/
ctrl.maxvwgt = 1.5*(idxsum(graph.nvtxs, graph.vwgt)/ctrl.CoarsenTo);
AllocateWorkSpace(&ctrl, &graph, 2);
if (ctrl.oflags&OFLAG_CCMP)
MlevelNestedDissectionCC(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, graph.nvtxs);
else
MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, graph.nvtxs);
FreeWorkSpace(&ctrl, &graph);
if (ctrl.pfactor > 0) { /* Order any prunned vertices */
if (graph.nvtxs < *nvtxs) {
idxcopy(graph.nvtxs, iperm, perm); /* Use perm as an auxiliary array */
for (i=0; i<graph.nvtxs; i++)
iperm[piperm[i]] = perm[i];
for (i=graph.nvtxs; i<*nvtxs; i++)
iperm[piperm[i]] = i;
}
GKfree(&piperm, LTERM);
}
else if (ctrl.oflags&OFLAG_COMPRESS) { /* Uncompress the ordering */
if (graph.nvtxs < COMPRESSION_FRACTION*(*nvtxs)) {
/* construct perm from iperm */
for (i=0; i<graph.nvtxs; i++)
perm[iperm[i]] = i;
for (l=ii=0; ii<graph.nvtxs; ii++) {
i = perm[ii];
for (j=cptr[i]; j<cptr[i+1]; j++)
iperm[cind[j]] = l++;
}
}
GKfree(&cptr, &cind, LTERM);
}
for (i=0; i<*nvtxs; i++)
perm[iperm[i]] = i;
IFSET(ctrl.dbglvl, DBG_TIME, stoptimer(ctrl.TotalTmr));
IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl));
if (*numflag == 1)
Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm);
}
int main(void)
{
DDRD = 0b01110000;
DDRA = 0b00000001;
//wdt_reset();
//wdt_disable();
char replyDat[2];
i2c_init();
USART roverPort;
USART devicePort;
CommInterface inf;
CommPacket commPkt;
char commData[20];
char commRet;
Timer accelTimer;
Timer dataTimer;
int sensorError;
//PORTA = 1;
//_delay_ms(250);
//PORTA = 0;
//_delay_ms(250);
USART_InitPortStructs();
setDeviceCamera();
USART_Open(&roverPort, 0, USART_BAUD_38400, 20, 32, true);
CommInterfaceInit(&inf, &roverPort);
USART_Open(&devicePort, 1, USART_BAUD_9600, 20, 5, false);
setDeviceServo();
sensorError = InitAccelerometer(&inf);
sensorError = InitBarometer(&inf);
InitServos(&devicePort);
InitCamera(&devicePort);
InitTimers();
//StartTimer(&accelTimer);
//StartTimer(&dataTimer);
setDeviceServo();
PORTA |= 1;
PanTiltSetPosition(TILT_SERVO, TILT_CENTER);
PanTiltSetPosition(PAN_SERVO, PAN_CENTER);
char pingRespond = 0xAA;
commPkt.data = commData;
CommPacket pkt;
char textBuffer[40];
char length;
unsigned char aclBuf[6];
//ServiceBarometer(3);
//Enable Watchdog
//wdt_enable(0b111);
while(1) {
while(CommRXPacketsAvailable(&inf)) {
commRet = CommGetPacket(&inf, &commPkt, 20);
if (!commRet) // didn't get packet returned, even though it said we had one. give up for now
break;
if (commPkt.length==0) { // bad 0-length packet, skip to the next one
continue;
}
// must at least have a length of 1, check the first byte to see what device this is targeted at
if (commPkt.data[0]==SYS_PANTILT) {
PORTA &= ~1;
setDeviceServo();
PanTiltHandlePacket(&commPkt);
PORTA = sensorError;
}
else if (commPkt.data[0]==SYS_CAMERA) {
PORTA &= ~1;
setDeviceCamera();
CameraHandlePacket(&commPkt);
PORTA = sensorError;
}
else if (commPkt.data[0]==SYS_BAROMETER) {
PORTA &= ~1;
BarometerHandlePacket(&commPkt);
PORTA = sensorError;
}
else if (commPkt.data[0]==SYS_ACCEL) {
PORTA &= ~1;
AccelHandlePacket(&commPkt);
PORTA = sensorError;
}
else if (commPkt.data[0]==SYS_PING)
{
pkt.target = 1;
pkt.length = 1;
pkt.data = &pingRespond;
CommSendPacket(&inf,&pkt);
}
}
/*
if (GetSpanUs(&dataTimer) > FROM_uS(1000000))
{
USART_WriteByte(&roverPort,0xFE);
USART_WriteByte(&roverPort,temperatureData>>8);
USART_WriteByte(&roverPort,temperatureData&0xFF);
USART_WriteByte(&roverPort,barometerData>>16);
USART_WriteByte(&roverPort,(barometerData>>8)&0xFF);
USART_WriteByte(&roverPort,barometerData&0xFF);
AccelGetAverage(aclBuf);
length = sprintf(textBuffer,"X: %d \tY: %d \n\r",(aclBuf[0]<<8)|aclBuf[1], (aclBuf[2]<<8)|aclBuf[3]);
USART_Write(&roverPort,textBuffer,length);
StartTimer(&dataTimer);
}
*/
/*
if (GetSpanUs(&accelTimer) > 39)
{
sensorError |= AccelAddDataToBuffer();
StartTimer(&accelTimer);
}
if (BarometerGetState() == 1)
{
sensorError |= ServiceBarometer(3);
}*/
}
}
