void *globalAlloc(int size)
{
return memAlloc(&globals, size);
}
void
METISNAMEU(METIS_PartGraphVKway) (
const int * const n,
const int * const xadj,
const int * const adjncy,
const int * const vwgt,
const int * const vsize,
const int * const wgtflag,
const int * const numflag,
const int * const nparts,
const int * const options,
int * const volume,
int * const part)
{
int baseval;
const int * vwgt2;
const int * vsize2;
int vsizval; /* Communication volume of current vertex */
int vertnbr;
int vertnum;
int edgenum;
const int * restrict edgetax;
const int * restrict parttax;
int * restrict nghbtab;
int commvol;
vsize2 = ((*wgtflag & 1) != 0) ? vsize : NULL;
vwgt2 = ((*wgtflag & 2) != 0) ? vwgt : NULL;
baseval = *numflag;
vertnbr = *n;
edgetax = adjncy - baseval;
if (vsize2 == NULL) /* If no communication load data provided */
_SCOTCH_METIS_PartGraph (n, xadj, adjncy, vwgt2, NULL, numflag, nparts, part);
else { /* Will have to turn communication volumes into edge loads */
const int * restrict vsiztax;
int edgenbr;
int * restrict edlotax;
int o;
edgenbr = xadj[vertnbr] - baseval;
if ((edlotax = memAlloc (edgenbr * sizeof (int))) == NULL)
return;
edlotax -= baseval; /* Base access to edlotax */
vsiztax = vsize2 - baseval;
for (vertnum = 0, edgenum = baseval; /* Un-based scan of vertex array xadj */
vertnum < vertnbr; vertnum ++) {
int vsizval; /* Communication size of current vertex */
int edgennd;
vsizval = vsize2[vertnum];
for (edgennd = xadj[vertnum + 1]; edgenum < edgennd; edgenum ++) { /* Based traversal of edge array adjncy */
int vertend; /* Based end vertex number */
vertend = edgetax[edgenum];
edlotax[edgenum] = vsizval + vsiztax[vertend];
}
}
o = _SCOTCH_METIS_PartGraph (n, xadj, adjncy, vwgt2, edlotax + baseval, numflag, nparts, part);
memFree (edlotax + baseval);
if (o != 0)
return;
}
if ((nghbtab = memAlloc (*nparts * sizeof (int))) == NULL)
return;
memSet (nghbtab, ~0, *nparts * sizeof (int));
parttax = part - baseval;
vsizval = 1; /* Assume no vertex communication sizes */
for (vertnum = 0, edgenum = baseval, commvol = 0; /* Un-based scan of vertex array xadj */
vertnum < vertnbr; vertnum ++) {
int partval;
int edgennd;
partval = part[vertnum];
nghbtab[partval] = vertnum; /* Do not count local neighbors in communication volume */
if (vsize2 != NULL)
vsizval = vsize2[vertnum];
for (edgennd = xadj[vertnum + 1]; edgenum < edgennd; edgenum ++) { /* Based traversal of edge array adjncy */
int vertend; /* Based end vertex number */
int partend;
vertend = edgetax[edgenum];
partend = parttax[vertend];
if (nghbtab[partend] != vertnum) { /* If first neighbor in this part */
nghbtab[partend] = vertnum; /* Set part as accounted for */
commvol += vsizval;
}
}
}
*volume = commvol;
memFree (nghbtab);
}
int
bdgraphBipartBd (
Bdgraph * const orggrafptr, /*+ Distributed graph +*/
const BdgraphBipartBdParam * const paraptr) /*+ Method parameters +*/
{
Bdgraph bndgrafdat; /* Bipartitioning band graph structure */
Gnum bndvertancnnd; /* End of local vertex array, without anchors */
Gnum bndvertlocnbr1; /* Number of band graph vertices in part 1 except anchor 1 */
Gnum bndvertlocnum;
Gnum bndvertlvlnum; /* Based number of first band vertex in last layer */
Gnum bndvertlocancadj; /* Flag set when anchor(s) represent unexistent vertices */
Gnum bndvertglbancadj; /* Global adjustment of anchor vertices */
Gnum bndveexlocsum; /* Local sum of veexloctax array cells for band graph */
Gnum bndveexlocsum0; /* Local sum of veexloctax array cells in part 0 for band graph */
Gnum bndedlolocval;
Gnum bndfronlocnum;
Gnum orgfronlocnum;
int * restrict orgflagloctab;
Gnum orgvertlocnum;
Gnum orgedlolocval;
const int * restrict orgprocsidtab;
int orgprocsidnbr;
int orgprocsidnum;
int orgprocsidval;
Gnum complocsizeadj0;
Gnum commlocloadintn;
Gnum commlocloadintn2; /* Twice twice (4 times) the internal communication load of last layer */
Gnum commlocloadextn;
Gnum commlocgainextn;
Gnum reduloctab[7];
Gnum reduglbtab[7];
DgraphHaloRequest requdat;
if (orggrafptr->fronglbnbr == 0) /* If no separator vertices, apply strategy to full (original) graph */
return (bdgraphBipartSt (orggrafptr, paraptr->stratorg));
if (dgraphBand (&orggrafptr->s, orggrafptr->fronlocnbr, orggrafptr->fronloctab, orggrafptr->partgsttax,
orggrafptr->complocload0, orggrafptr->s.velolocsum - orggrafptr->complocload0, paraptr->distmax,
&bndgrafdat.s, &bndgrafdat.fronloctab, &bndgrafdat.partgsttax,
&bndvertlvlnum, &bndvertlocnbr1, &bndvertlocancadj) != 0) {
errorPrint ("bdgraphBipartBd: cannot create band graph");
return (1);
}
bndvertancnnd = bndgrafdat.s.vertlocnnd - 2;
reduloctab[0] = 0; /* Assume no memory allocation problem */
bndveexlocsum =
bndveexlocsum0 = 0;
bndgrafdat.veexloctax = NULL; /* Assume no external gains */
if (orggrafptr->veexloctax != NULL) {
if ((bndgrafdat.veexloctax = memAlloc (bndgrafdat.s.vertlocnbr * sizeof (Gnum))) == NULL) {
errorPrint ("bdgraphBipartBd: out of memory (1)");
reduloctab[0] = 1; /* Memory error */
}
else {
Gnum bndvertlocnum;
bndgrafdat.veexloctax -= bndgrafdat.s.baseval;
for (bndvertlocnum = bndgrafdat.s.baseval; bndvertlocnum < bndvertancnnd; bndvertlocnum ++) {
Gnum veexval;
veexval = orggrafptr->veexloctax[bndgrafdat.s.vnumloctax[bndvertlocnum]];
bndgrafdat.veexloctax[bndvertlocnum] = veexval;
bndveexlocsum += veexval;
bndveexlocsum0 += veexval & (((Gnum) bndgrafdat.partgsttax[bndvertlocnum]) - 1);
}
}
}
reduloctab[1] = bndgrafdat.s.vendloctax[bndvertancnnd] - bndgrafdat.s.vertloctax[bndvertancnnd] - (orggrafptr->s.procglbnbr - 1); /* Anchor degrees */
reduloctab[2] = bndgrafdat.s.vendloctax[bndvertancnnd + 1] - bndgrafdat.s.vertloctax[bndvertancnnd + 1] - (orggrafptr->s.procglbnbr - 1);
bndgrafdat.complocsize0 = bndgrafdat.s.vertlocnbr - (bndvertlocnbr1 + 1); /* Add 1 for anchor vertex 1 */
complocsizeadj0 = orggrafptr->complocsize0 - bndgrafdat.complocsize0; /* -1 less because of anchor 0 */
reduloctab[3] = bndgrafdat.complocsize0;
reduloctab[4] = bndvertlocancadj; /* Sum increases in size and load */
reduloctab[5] = bndveexlocsum;
reduloctab[6] = bndveexlocsum0;
if (MPI_Allreduce (reduloctab, reduglbtab, 7, GNUM_MPI, MPI_SUM, orggrafptr->s.proccomm) != MPI_SUCCESS) {
errorPrint ("bdgraphBipartBd: communication error (1)");
return (1);
}
if (reduglbtab[0] != 0) {
bdgraphExit (&bndgrafdat);
return (1);
}
if ((reduglbtab[1] == 0) || /* If graph is too small to have any usable anchors */
(reduglbtab[2] == 0)) {
bdgraphExit (&bndgrafdat);
return (bdgraphBipartSt (orggrafptr, paraptr->stratorg));
}
bndvertglbancadj = reduglbtab[4];
bndgrafdat.veexglbsum = orggrafptr->veexglbsum; /* All external gains preserved */
bndgrafdat.fronlocnbr = orggrafptr->fronlocnbr; /* All separator vertices are kept in band graph */
bndgrafdat.fronglbnbr = orggrafptr->fronglbnbr;
bndgrafdat.complocload0 = orggrafptr->complocload0 + bndvertlocancadj; /* All loads are kept in band graph */
bndgrafdat.compglbload0 = orggrafptr->compglbload0 + bndvertglbancadj;
bndgrafdat.compglbload0min = orggrafptr->compglbload0min + bndvertglbancadj; /* Tilt extrema loads according to adjustments */
bndgrafdat.compglbload0max = orggrafptr->compglbload0max + bndvertglbancadj;
bndgrafdat.compglbload0avg = orggrafptr->compglbload0avg + bndvertglbancadj; /* Tilt average load according to adjustments */
bndgrafdat.compglbload0dlt = orggrafptr->compglbload0dlt;
bndgrafdat.compglbsize0 = reduglbtab[3];
bndgrafdat.commglbload = orggrafptr->commglbload;
bndgrafdat.commglbgainextn = orggrafptr->commglbgainextn;
bndgrafdat.commglbloadextn0 = orggrafptr->commglbloadextn0;
bndgrafdat.commglbgainextn0 = orggrafptr->commglbgainextn0;
bndgrafdat.domdist = orggrafptr->domdist;
bndgrafdat.domwght[0] = orggrafptr->domwght[0];
bndgrafdat.domwght[1] = orggrafptr->domwght[1];
bndgrafdat.levlnum = orggrafptr->levlnum;
if (bndgrafdat.veexloctax != NULL) {
Gnum bndveexglbanc0;
Gnum bndveexglbanc1;
bndveexglbanc0 = (orggrafptr->veexglbsum + orggrafptr->commglbgainextn) / 2 - reduglbtab[6]; /* Compute global external gains of anchors */
bndveexglbanc1 = (orggrafptr->veexglbsum - bndveexglbanc0) - reduglbtab[5];
bndgrafdat.veexloctax[bndvertancnnd] = DATASIZE (bndveexglbanc0, bndgrafdat.s.procglbnbr, bndgrafdat.s.proclocnum); /* Spread gains across local anchors */
bndgrafdat.veexloctax[bndvertancnnd + 1] = DATASIZE (bndveexglbanc1, bndgrafdat.s.procglbnbr, bndgrafdat.s.proclocnum);
}
#ifdef SCOTCH_DEBUG_BDGRAPH2
if (bdgraphCheck (&bndgrafdat) != 0) {
errorPrint ("bdgraphBipartBd: internal error (1)");
return (1);
}
#endif /* SCOTCH_DEBUG_BDGRAPH2 */
if (bdgraphBipartSt (&bndgrafdat, paraptr->stratbnd) != 0) { /* Separate distributed band graph */
errorPrint ("bdgraphBipartBd: cannot separate band graph");
bdgraphExit (&bndgrafdat);
return (1);
}
reduloctab[0] = (Gnum) bndgrafdat.partgsttax[bndvertancnnd]; /* Check if anchor vertices remain in their parts */
reduloctab[1] = (Gnum) bndgrafdat.partgsttax[bndvertancnnd + 1];
reduloctab[2] = complocsizeadj0;
reduloctab[3] = 0; /* Assume memory allocation is all right */
if ((orgflagloctab = memAlloc (flagSize (orggrafptr->s.vertlocnnd) * sizeof (int))) == NULL) { /* Eventually keep space for based indices */
errorPrint ("bdgraphBipartBd: out of memory (2)");
reduloctab[3] = 1;
}
if (MPI_Allreduce (&reduloctab[0], &reduglbtab[0], 4, GNUM_MPI, MPI_SUM, orggrafptr->s.proccomm) != MPI_SUCCESS) {
errorPrint ("bdgraphBipartBd: communication error (2)");
return (1);
}
if (((reduglbtab[0] + reduglbtab[1]) != orggrafptr->s.procglbnbr) || /* If not all anchors of initial same parts in same parts */
((reduglbtab[0] != 0) && (reduglbtab[0] != orggrafptr->s.procglbnbr)) ||
(reduglbtab[3] != 0)) {
if (orgflagloctab != NULL)
memFree (orgflagloctab);
bdgraphExit (&bndgrafdat); /* Apply original strategy to full graph */
return (bdgraphBipartSt (orggrafptr, paraptr->stratorg));
}
if (dgraphGhst (&bndgrafdat.s) != 0) { /* Compute ghost edge array if not already present */
errorPrint ("bdgraphBipartBd: cannot compute ghost edge array");
return (1);
}
if (reduglbtab[0] == orggrafptr->s.procglbnbr) { /* If all anchors swapped parts, swap all parts of original vertices */
Gnum orgvertnum;
orggrafptr->complocsize0 = orggrafptr->s.vertlocnbr - reduloctab[2] - bndgrafdat.s.vertlocnbr + bndgrafdat.complocsize0;
orggrafptr->compglbsize0 = orggrafptr->s.vertglbnbr - reduglbtab[2] - bndgrafdat.s.vertglbnbr + bndgrafdat.compglbsize0;
for (orgvertnum = orggrafptr->s.baseval; orgvertnum < orggrafptr->s.vertlocnnd; orgvertnum ++)
orggrafptr->partgsttax[orgvertnum] ^= 1;
}
else {
orggrafptr->complocsize0 = reduloctab[2] + bndgrafdat.complocsize0;
orggrafptr->compglbsize0 = reduglbtab[2] + bndgrafdat.compglbsize0;
}
for (bndvertlocnum = bndgrafdat.s.baseval; bndvertlocnum < bndvertancnnd; bndvertlocnum ++) /* Update part array of all vertices except anchors */
orggrafptr->partgsttax[bndgrafdat.s.vnumloctax[bndvertlocnum]] = bndgrafdat.partgsttax[bndvertlocnum];
dgraphHaloAsync (&orggrafptr->s, (byte *) (orggrafptr->partgsttax + orggrafptr->s.baseval), GRAPHPART_MPI, &requdat); /* Share part array of full graph */
commlocloadintn =
commlocloadextn =
commlocgainextn = 0;
bndedlolocval = 1; /* Assume no edge loads */
for (bndvertlocnum = bndgrafdat.s.baseval; bndvertlocnum < bndvertlvlnum; bndvertlocnum ++) { /* For all vertices of band graph save for last layer */
Gnum bndedgelocnum;
Gnum bndedgelocnnd;
Gnum bndpartval;
bndpartval = (Gnum) bndgrafdat.partgsttax[bndvertlocnum];
if (bndgrafdat.veexloctax != NULL) {
commlocloadextn += bndgrafdat.veexloctax[bndvertlocnum] * bndpartval;
commlocgainextn += bndgrafdat.veexloctax[bndvertlocnum] * (1 - bndpartval * 2);
}
for (bndedgelocnum = bndgrafdat.s.vertloctax[bndvertlocnum], bndedgelocnnd = bndgrafdat.s.vendloctax[bndvertlocnum];
bndedgelocnum < bndedgelocnnd; bndedgelocnum ++) {
Gnum bndvertlocend;
Gnum bndpartend;
bndvertlocend = bndgrafdat.s.edgegsttax[bndedgelocnum];
bndpartend = bndgrafdat.partgsttax[bndvertlocend];
if (bndgrafdat.s.edloloctax != NULL)
bndedlolocval = bndgrafdat.s.edloloctax[bndedgelocnum];
commlocloadintn += (bndpartval ^ bndpartend) * bndedlolocval; /* Internal load is accounted for twice */
}
}
for ( ; bndvertlocnum < bndvertancnnd; bndvertlocnum ++) { /* For all vertices of last layer, remove internal loads to band vertices once */
Gnum bndedgelocnum;
Gnum bndedgelocnnd;
Gnum bndpartval;
bndpartval = (Gnum) bndgrafdat.partgsttax[bndvertlocnum];
if (bndgrafdat.veexloctax != NULL) {
commlocloadextn += bndgrafdat.veexloctax[bndvertlocnum] * bndpartval;
commlocgainextn += bndgrafdat.veexloctax[bndvertlocnum] * (1 - bndpartval * 2);
}
for (bndedgelocnum = bndgrafdat.s.vertloctax[bndvertlocnum], bndedgelocnnd = bndgrafdat.s.vendloctax[bndvertlocnum] - 1; /* "-1" to avoid anchor edges */
bndedgelocnum < bndedgelocnnd; bndedgelocnum ++) {
Gnum bndvertlocend;
Gnum bndpartend;
bndvertlocend = bndgrafdat.s.edgegsttax[bndedgelocnum];
bndpartend = bndgrafdat.partgsttax[bndvertlocend];
if (bndgrafdat.s.edloloctax != NULL)
bndedlolocval = bndgrafdat.s.edloloctax[bndedgelocnum];
commlocloadintn -= (bndpartval ^ bndpartend) * bndedlolocval; /* Remove internal loads to band graph vertices once because afterwards they will be accounted for twice */
}
}
memSet (orgflagloctab, 0, flagSize (orggrafptr->s.vertlocnnd) * sizeof (int)); /* Set vertices as not already considered */
for (bndfronlocnum = orgfronlocnum = 0; bndfronlocnum < bndgrafdat.fronlocnbr; bndfronlocnum ++) { /* Project back separator except for last layer */
Gnum bndvertlocnum;
bndvertlocnum = bndgrafdat.fronloctab[bndfronlocnum];
if (bndvertlocnum < bndvertlvlnum) { /* If vertex does not belong to last layer */
Gnum orgvertlocnum;
orgvertlocnum = bndgrafdat.s.vnumloctax[bndvertlocnum];
flagSet (orgflagloctab, orgvertlocnum); /* Set vertex as processed */
orggrafptr->fronloctab[orgfronlocnum ++] = orgvertlocnum;
}
}
if (dgraphHaloWait (&requdat) != 0) {
errorPrint ("bdgraphBipartBd: cannot complete asynchronous halo exchange");
return (1);
}
orgedlolocval = 1; /* Assume no edge loads */
commlocloadintn2 = 0;
for (bndvertlocnum = bndvertlvlnum; bndvertlocnum < bndvertancnnd; bndvertlocnum ++) { /* For all vertices of last layer */
Gnum orgedgelocnum;
Gnum orgedgelocnnd;
Gnum orgvertlocnum;
GraphPart orgpartval;
Gnum orgflagval;
orgvertlocnum = bndgrafdat.s.vnumloctax[bndvertlocnum];
orgpartval = bndgrafdat.partgsttax[bndvertlocnum];
orgflagval = 0; /* Assume vertex does not belong to the frontier */
for (orgedgelocnum = orggrafptr->s.vertloctax[orgvertlocnum], orgedgelocnnd = orggrafptr->s.vendloctax[orgvertlocnum];
orgedgelocnum < orgedgelocnnd; orgedgelocnum ++) {
Gnum orgvertlocend;
Gnum orgpartend;
Gnum orgflagtmp;
orgvertlocend = orggrafptr->s.edgegsttax[orgedgelocnum];
orgpartend = orggrafptr->partgsttax[orgvertlocend];
orgflagtmp = orgpartval ^ orgpartend;
if (bndgrafdat.s.edloloctax != NULL)
orgedlolocval = orggrafptr->s.edloloctax[orgedgelocnum];
orgflagval |= orgflagtmp;
commlocloadintn2 += orgflagtmp * orgedlolocval; /* Internal load to band and original graph vertices are accounted for twice */
if ((orgflagtmp != 0) && (orgvertlocend < orggrafptr->s.vertlocnnd) && (flagVal (orgflagloctab, orgvertlocend) == 0)) {
orggrafptr->fronloctab[orgfronlocnum ++] = orgvertlocend;
flagSet (orgflagloctab, orgvertlocend);
}
}
if ((orgflagval != 0) && (flagVal (orgflagloctab, orgvertlocnum) == 0))
orggrafptr->fronloctab[orgfronlocnum ++] = orgvertlocnum;
flagSet (orgflagloctab, orgvertlocnum); /* Set vertex as processed anyway */
}
commlocloadintn += 2 * commlocloadintn2; /* Add twice the internal load of original graph edges and once the one of band edges (one removed before) */
orggrafptr->complocload0 = bndgrafdat.complocload0 - bndvertlocancadj;
orggrafptr->compglbload0 = bndgrafdat.compglbload0 - bndvertglbancadj;
orggrafptr->compglbload0dlt = orggrafptr->compglbload0 - orggrafptr->compglbload0avg;
orgprocsidnbr = orggrafptr->s.procsidnbr;
if (orgprocsidnbr == 0)
goto loop_exit;
orgvertlocnum = orggrafptr->s.baseval;
orgprocsidnum = 0;
orgprocsidtab = orggrafptr->s.procsidtab;
orgprocsidval = orgprocsidtab[orgprocsidnum ++];
while (1) { /* Scan all vertices which have foreign neighbors */
while (orgprocsidval < 0) {
orgvertlocnum -= (Gnum) orgprocsidval;
orgprocsidval = orgprocsidtab[orgprocsidnum ++];
}
if (flagVal (orgflagloctab, orgvertlocnum) == 0) { /* If vertex not already processed */
Gnum orgedgelocnum;
Gnum orgedgelocnnd;
GraphPart orgpartval;
orgpartval = orggrafptr->partgsttax[orgvertlocnum];
for (orgedgelocnum = orggrafptr->s.vertloctax[orgvertlocnum], orgedgelocnnd = orggrafptr->s.vendloctax[orgvertlocnum];
orgedgelocnum < orgedgelocnnd; orgedgelocnum ++) {
if (orggrafptr->partgsttax[orggrafptr->s.edgegsttax[orgedgelocnum]] != orgpartval) {
orggrafptr->fronloctab[orgfronlocnum ++] = orgvertlocnum;
break;
}
}
}
do {
if (orgprocsidnum >= orgprocsidnbr)
goto loop_exit;
} while ((orgprocsidval = orgprocsidtab[orgprocsidnum ++]) >= 0);
}
loop_exit :
memFree (orgflagloctab);
reduloctab[0] = commlocloadintn; /* Twice the internal load; sum globally before dividing by two */
reduloctab[1] = commlocloadextn;
reduloctab[2] = commlocgainextn;
reduloctab[3] = orgfronlocnum;
if (MPI_Allreduce (&reduloctab[0], &reduglbtab[0], 4, GNUM_MPI, MPI_SUM, orggrafptr->s.proccomm) != MPI_SUCCESS) {
errorPrint ("bdgraphBipartBd: communication error (3)");
return (1);
}
orggrafptr->fronlocnbr = orgfronlocnum;
orggrafptr->fronglbnbr = reduglbtab[3];
orggrafptr->commglbload = (reduglbtab[0] / 2) * orggrafptr->domdist + reduglbtab[1];
orggrafptr->commglbgainextn = reduglbtab[2];
#ifdef SCOTCH_DEBUG_BDGRAPH2
if (bdgraphCheck (orggrafptr) != 0) {
errorPrint ("bdgraphBipartBd: internal error (2)");
return (1);
}
#endif /* SCOTCH_DEBUG_BDGRAPH2 */
bdgraphExit (&bndgrafdat);
return (0);
}
static GLUface *allocFace()
{
return (GLUface *)memAlloc( sizeof( GLUface ));
}
static
int
graphMapCompute2 (
SCOTCH_Graph * const grafptr, /*+ Graph to order +*/
SCOTCH_Mapping * const mappptr, /*+ Mapping to compute +*/
SCOTCH_Mapping * const mapoptr, /*+ Old mapping +*/
const double emraval, /*+ Edge migration ratio +*/
const SCOTCH_Num * vmlotab, /*+ Vertex migration cost array +*/
Gnum vfixval, /*+ Equal to 0 if no fixed vertices +*/
SCOTCH_Strat * const straptr) /*+ Mapping strategy +*/
{
Kgraph mapgrafdat; /* Effective mapping graph */
const Strat * mapstraptr; /* Pointer to mapping strategy */
LibMapping * restrict lmapptr;
LibMapping * restrict lmaoptr;
Anum * pfixtax;
Gnum baseval;
Anum * parttax; /* Partition array */
Anum * parotax; /* Old partition array */
Gnum crloval; /* Coefficient load for regular edges */
Gnum cmloval; /* Coefficient load for migration edges */
const Gnum * vmlotax; /* Vertex migration cost array */
Gnum vertnum;
Gnum vertnnd;
Gnum vertnbr;
int o;
lmapptr = (LibMapping *) mappptr;
#ifdef SCOTCH_DEBUG_GRAPH2
if ((Graph *) grafptr != lmapptr->grafptr) {
errorPrint ("graphMapCompute2: output mapping does not correspond to input graph");
return (1);
}
if (graphCheck ((Graph *) grafptr) != 0) { /* Vertex loads can be 0 if we have fixed vertices */
errorPrint ("graphMapCompute2: invalid input graph");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
if (*((Strat **) straptr) == NULL) { /* Set default mapping strategy if necessary */
ArchDom archdomnorg;
archDomFrst (lmapptr->archptr, &archdomnorg);
SCOTCH_stratGraphMapBuild (straptr, SCOTCH_STRATDEFAULT, archDomSize (lmapptr->archptr, &archdomnorg), 0.01);
}
mapstraptr = *((Strat **) straptr);
if (mapstraptr->tabl != &kgraphmapststratab) {
errorPrint ("graphMapCompute2: not a graph mapping strategy");
return (1);
}
baseval = lmapptr->grafptr->baseval;
vertnbr = lmapptr->grafptr->vertnbr;
if (mapoptr != NULL) { /* We are doing a repartitioning */
LibMapping * lmaoptr;
Gnum numeval;
Gnum denoval;
lmaoptr = (LibMapping *) mapoptr;
#ifdef SCOTCH_DEBUG_GRAPH2
if (lmapptr->grafptr != lmaoptr->grafptr) {
errorPrint ("graphMapCompute2: output and old mapping must correspond to the same graph");
return (1);
}
if (lmapptr->archptr != lmaoptr->archptr) {
errorPrint ("graphMapCompute2: output and old mapping must correspond to the same architecture");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
parotax = lmaoptr->parttab - baseval;
vmlotax = (vmlotab != NULL) ? vmlotab - baseval : NULL;
numeval = (INT) ((emraval * 100.0) + 0.5);
denoval = intGcd (numeval, 100);
cmloval = numeval / denoval;
crloval = 100 / denoval;
}
else {
parotax = NULL;
vmlotax = NULL;
cmloval =
crloval = 1;
}
parttax = NULL;
if (vfixval != 0) { /* We have fixed vertices */
#ifdef SCOTCH_DEBUG_GRAPH2
if (lmapptr->parttab == NULL) { /* We must have fixed vertices information */
errorPrint ("graphMapCompute2: missing output mapping part array");
return (1);
}
#endif /* SCOTCH_DEBUG_GRAPH2 */
pfixtax = lmapptr->parttab - baseval;
if ((parttax = (Anum *) memAlloc (vertnbr * sizeof (Anum))) == NULL) {
errorPrint ("graphMapCompute2: out of memory (1)");
return (1);
}
memSet (parttax, 0, vertnbr * sizeof (Anum)); /* All vertices mapped to first domain */
parttax -= baseval;
} else {
pfixtax = NULL;
if (lmapptr->parttab == NULL) { /* If user mapping not initialized */
errorPrint ("graphMapCompute2: invalid user mapping");
return (1);
}
parttax = lmapptr->parttab - baseval;
}
intRandInit (); /* Check that random number generator is initialized */
if (kgraphInit (&mapgrafdat, (Graph *) grafptr, lmapptr->archptr, NULL, parttax, parotax, crloval, cmloval, vmlotax, pfixtax) != 0)
return (1);
o = 0;
if (mapgrafdat.vfixnbr != mapgrafdat.s.vertnbr) { /* Perform mapping if not all fixed vertices */
o = kgraphMapSt (&mapgrafdat, mapstraptr);
lmapptr->parttab -= baseval;
for (vertnum = baseval, vertnnd = vertnum + lmapptr->grafptr->vertnbr;
vertnum < vertnnd; vertnum ++)
lmapptr->parttab[vertnum] = archDomNum (lmapptr->archptr, &mapgrafdat.m.domntab[mapgrafdat.m.parttax[vertnum]]);
lmapptr->parttab += baseval;
}
if (vfixval != 0) /* We have fixed vertices */
memFree (parttax + baseval);
kgraphExit (&mapgrafdat);
return (o);
}
SCOTCH_Dordering *
SCOTCH_dorderAlloc ()
{
return ((SCOTCH_Dordering *) memAlloc (sizeof (SCOTCH_Dordering)));
}
int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList)
{
OOSOCKET sock;
struct ifconf ifc;
int ifNum;
OOInterface *pIf=NULL;
struct sockaddr_in sin;
OOTRACEDBGA1("Retrieving local interfaces\n");
if(ooSocketCreateUDP(&sock)!= ASN_OK)
{
OOTRACEERR1("Error:Failed to create udp socket - "
"ooSocketGetInterfaceList\n");
return -1;
}
#ifdef SIOCGIFNUM
if(ioctl(sock, SIOCGIFNUM, &ifNum) >= 0)
{
OOTRACEERR1("Error: ioctl for ifNum failed\n");
return -1;
}
#else
ifNum = 50;
#endif
ifc.ifc_len = ifNum * sizeof(struct ifreq);
ifc.ifc_req = (struct ifreq *)memAlloc(pctxt, ifNum *sizeof(struct ifreq));
if(!ifc.ifc_req)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - ifc.ifc_req\n");
return -1;
}
if (ioctl(sock, SIOCGIFCONF, &ifc) >= 0) {
void * ifEndList = (char *)ifc.ifc_req + ifc.ifc_len;
struct ifreq *ifName;
struct ifreq ifReq;
int flags;
for (ifName = ifc.ifc_req; (void*)ifName < ifEndList; ifName++) {
char *pName=NULL;
char addr[50];
#ifdef ifr_netmask
char mask[50];
#endif
pIf = (struct OOInterface*)memAlloc(pctxt, sizeof(struct OOInterface));
pName = (char*)memAlloc(pctxt, strlen(ifName->ifr_name)+1);
if(!pIf)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf/pName\n");
return -1;
}
OOTRACEDBGA2("\tInterface name: %s\n", ifName->ifr_name);
strcpy(ifReq.ifr_name, ifName->ifr_name);
strcpy(pName, ifName->ifr_name);
pIf->name = pName;
/* Check whether the interface is up*/
if (ioctl(sock, SIOCGIFFLAGS, &ifReq) < 0) {
OOTRACEERR2("Error:Unable to determine status of interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
flags = ifReq.ifr_flags;
if (!(flags & IFF_UP)) {
OOTRACEWARN2("Warn:Interface %s is not up\n", pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
/* Retrieve interface address */
if (ioctl(sock, SIOCGIFADDR, &ifReq) < 0)
{
OOTRACEWARN2("Warn:Unable to determine address of interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
continue;
}
memcpy(&sin, &ifReq.ifr_addr, sizeof(struct sockaddr_in));
strcpy(addr, ast_inet_ntoa(sin.sin_addr));
OOTRACEDBGA2("\tIP address is %s\n", addr);
pIf->addr = (char*)memAlloc(pctxt, strlen(addr)+1);
if(!pIf->addr)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf->addr\n");
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf);
return -1;
}
strcpy(pIf->addr, addr);
#ifdef ifr_netmask
if (ioctl(sock, SIOCGIFNETMASK, &ifReq) < 0)
{
OOTRACEWARN2("Warn:Unable to determine mask for interface %s\n",
pName);
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf->addr);
memFreePtr(pctxt, pIf);
continue;
}
memcpy(&sin, &ifReq.ifr_netmask, sizeof(struct sockaddr_in));
strcpy(mask, ast_inet_ntoa(sin.sin_addr));
OOTRACEDBGA2("\tMask is %s\n", mask);
pIf->mask = (char*)memAlloc(pctxt, strlen(mask)+1);
if(!pIf->mask)
{
OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - "
"pIf->mask\n");
memFreePtr(pctxt, pIf->name);
memFreePtr(pctxt, pIf->addr);
memFreePtr(pctxt, pIf);
return -1;
}
strcpy(pIf->mask, mask);
#endif
pIf->next = NULL;
/* Add to the list */
if(!*ifList)
{
*ifList = pIf;
pIf = NULL;
}
else{
pIf->next = *ifList;
*ifList = pIf;
pIf=NULL;
}
/*
#if defined(OO_FREEBSD) || defined(OO_OPENBSD) || defined(OO_NETBSD) || defined(OO_MACOSX) || defined(OO_VXWORKS) || defined(OO_RTEMS) || defined(OO_QNX)
#ifndef _SIZEOF_ADDR_IFREQ
#define _SIZEOF_ADDR_IFREQ(ifr) \
((ifr).ifr_addr.sa_len > sizeof(struct sockaddr) ? \
(sizeof(struct ifreq) - sizeof(struct sockaddr) + \
(ifr).ifr_addr.sa_len) : sizeof(struct ifreq))
#endif
ifName = (struct ifreq *)((char *)ifName + _SIZEOF_ADDR_IFREQ(*ifName));
#else
ifName++;
*/
}
}
return ASN_OK;
}
/* really __gl_pqSortInit */
int pqInit( PriorityQ *pq )
{
PQkey **p, **r, **i, **j, *piv;
struct { PQkey **p, **r; } Stack[50], *top = Stack;
unsigned long seed = 2016473283;
/* Create an array of indirect pointers to the keys, so that we
* the handles we have returned are still valid.
*/
/*
pq->order = (PQHeapKey **)memAlloc( (size_t)
(pq->size * sizeof(pq->order[0])) );
*/
pq->order = (PQHeapKey **)memAlloc( (size_t)
((pq->size+1) * sizeof(pq->order[0])) );
/* the previous line is a patch to compensate for the fact that IBM */
/* machines return a null on a malloc of zero bytes (unlike SGI), */
/* so we have to put in this defense to guard against a memory */
/* fault four lines down. from [email protected]. */
if (pq->order == NULL) return 0;
p = pq->order;
r = p + pq->size - 1;
for( piv = pq->keys, i = p; i <= r; ++piv, ++i ) {
*i = piv;
}
/* Sort the indirect pointers in descending order,
* using randomized Quicksort
*/
top->p = p; top->r = r; ++top;
while( --top >= Stack ) {
p = top->p;
r = top->r;
while( r > p + 10 ) {
seed = seed * 1539415821 + 1;
i = p + seed % (r - p + 1);
piv = *i;
*i = *p;
*p = piv;
i = p - 1;
j = r + 1;
do {
do { ++i; } while( GT( **i, *piv ));
do { --j; } while( LT( **j, *piv ));
Swap( i, j );
} while( i < j );
Swap( i, j ); /* Undo last swap */
if( i - p < r - j ) {
top->p = j+1; top->r = r; ++top;
r = i-1;
} else {
top->p = p; top->r = i-1; ++top;
p = j+1;
}
}
/* Insertion sort small lists */
for( i = p+1; i <= r; ++i ) {
piv = *i;
for( j = i; j > p && LT( **(j-1), *piv ); --j ) {
*j = *(j-1);
}
*j = piv;
}
}
pq->max = pq->size;
pq->initialized = TRUE;
__gl_pqHeapInit( pq->heap ); /* always succeeds */
#ifndef NDEBUG
p = pq->order;
r = p + pq->size - 1;
for( i = p; i < r; ++i ) {
assert( LEQ( **(i+1), **i ));
}
#endif
return 1;
}
void *tAlloc(int size)
{
return memAlloc(&temps, size);
}
void *sAlloc(int size)
{
return memAlloc(&live, size);
}
void *aAlloc(int size)
{
return memAlloc(&alias, size);
}
void *oAlloc(int size)
{
return memAlloc(&opts, size);
}
void *localAlloc(int size)
{
return memAlloc(&locals, size);
}
bool MinelayerCorvetteStaticMineDrop(Ship *ship,SpaceObjRotImpTarg *target)
{
MinelayerCorvetteStatics *minelayercorvettestatics;
MinelayerCorvetteSpec *spec = (MinelayerCorvetteSpec *)ship->ShipSpecifics;
sdword flag = -1;
Gun *gun0,*gun1;
real32 time;
sdword maxmis;
minelayercorvettestatics = (MinelayerCorvetteStatics *) ((ShipStaticInfo *)(ship->staticinfo))->custstatinfo;
gun0 = ((Gun *) &(ship->gunInfo->guns[0]));
maxmis = gun0->gunstatic->maxMissiles;
if(ship->gunInfo->numGuns > 1)
{ //ship has 2 guns (race 1)
gun1 = ((Gun *) &(ship->gunInfo->guns[1]));
if(gun0->numMissiles == 0 && gun1->numMissiles == 0)
return FALSE;
if((universe.totaltimeelapsed - gun1->lasttimefired) < minelayercorvettestatics->gunReFireTime
&& (universe.totaltimeelapsed - gun0->lasttimefired) < minelayercorvettestatics->gunReFireTime)
{
return(FALSE);
}
maxmis += gun1->gunstatic->maxMissiles;
}
else
{
if(gun0->numMissiles == 0)
return FALSE;
if((universe.totaltimeelapsed - gun0->lasttimefired) < minelayercorvettestatics->gunReFireTime)
return(FALSE);
}
switch(spec->MiningStatus)
{
case FIRST_OFF:
//////////////////////
//speech event for forcedropped mines
//event num: COMM_MLVette_ForceDrop
//use battle chatter
if(ship->playerowner->playerIndex == universe.curPlayerIndex)
{
if (battleCanChatterAtThisTime(BCE_COMM_MLVette_ForceDrop, ship))
{
battleChatterAttempt(SOUND_EVENT_DEFAULT, BCE_COMM_MLVette_ForceDrop, ship, SOUND_EVENT_DEFAULT);
}
}
/////////////////////////
spec->MiningStatus = FIRST_OFF2;
case FIRST_OFF2:
if(aitrackZeroRotationAnywhere(ship))
{
flag = 2;
}
if(aitrackZeroVelocity(ship))
{
if(flag == 2)
{ //we're ready for next step
MineFormationInfo *mineformationinfo;
aitrackForceSteadyShip(ship); //stop movement, stop rotation
spec->MiningStatus = BEGIN_WALL_DROP_RIGHT;
spec->MiningSideMax = 1;
spec->MiningSideCount = 0;
matGetVectFromMatrixCol1(spec->formation_up,ship->rotinfo.coordsys);
matGetVectFromMatrixCol2(spec->formation_right,ship->rotinfo.coordsys);
vecScalarMultiply(spec->formation_up, spec->formation_up, minelayercorvettestatics->MineSpacing);
vecScalarMultiply(spec->formation_down, spec->formation_up, -1.0f);
vecScalarMultiply(spec->formation_right,spec->formation_right,minelayercorvettestatics->MineSpacing);
vecScalarMultiply(spec->formation_left,spec->formation_right,-1.0f);
matGetVectFromMatrixCol3(spec->formation_heading,ship->rotinfo.coordsys);
vecScalarMultiply(spec->formation_heading,spec->formation_heading,-minelayercorvettestatics->MineDropDistance);
//Create Formation Entity Here
mineformationinfo = memAlloc(sizeof(MineFormationInfo),"MineFormationInfo",NonVolatile);
listAddNode(&universe.MineFormationList,&(mineformationinfo->FormLink),mineformationinfo);
listInit(&mineformationinfo->MineList);
mineformationinfo->playerowner = ship->playerowner;
mineformationinfo->FULL = FALSE;
mineformationinfo->wallstate = PULSE_START;
mineformationinfo->effect = NULL;
spec->mineforminfo = mineformationinfo;
time = 29.0;
spec->mineforminfo->waittime = time; //set wait time for each pulse
spec->formation_number_X = 0;
spec->formation_number_Y = 0;
vecAdd(spec->formation_position,ship->posinfo.position,spec->formation_heading);
spec->mineaistate = MINE_DROP_FORMATION;
MinelayerCorvetteFire(ship,target);
spec->MineDropNumber = 1;
}
}
break;
case BEGIN_WALL_DROP_RIGHT:
vecAddTo(spec->formation_position,spec->formation_right);
spec->mineaistate = MINE_DROP_FORMATION;
MinelayerCorvetteFire(ship,target);
spec->MineDropNumber++;
spec->formation_number_X++;
spec->MiningSideCount++;
if(spec->MiningSideCount == spec->MiningSideMax)
{
spec->MiningSideCount = 0;
spec->MiningStatus = BEGIN_WALL_DROP_UP;
}
break;
case BEGIN_WALL_DROP_UP:
vecAddTo(spec->formation_position,spec->formation_up);
spec->mineaistate = MINE_DROP_FORMATION;
MinelayerCorvetteFire(ship,target);
spec->MineDropNumber++;
spec->formation_number_Y++;
spec->MiningSideCount++;
if(spec->MiningSideCount == spec->MiningSideMax)
{
spec->MiningSideMax++;
spec->MiningSideCount = 0;
spec->MiningStatus = BEGIN_WALL_DROP_LEFT;
}
break;
case BEGIN_WALL_DROP_LEFT:
vecAddTo(spec->formation_position,spec->formation_left);
spec->mineaistate = MINE_DROP_FORMATION;
MinelayerCorvetteFire(ship,target);
spec->MineDropNumber++;
spec->formation_number_X--;
spec->MiningSideCount++;
if(spec->MiningSideCount == spec->MiningSideMax)
{
spec->MiningSideCount = 0;
spec->MiningStatus = BEGIN_WALL_DROP_DOWN;
}
break;
case BEGIN_WALL_DROP_DOWN:
vecAddTo(spec->formation_position,spec->formation_down);
spec->mineaistate = MINE_DROP_FORMATION;
MinelayerCorvetteFire(ship,target);
spec->MineDropNumber++;
spec->formation_number_Y--;
spec->MiningSideCount++;
if(spec->MiningSideCount == spec->MiningSideMax)
{
spec->MiningSideMax++;
spec->MiningSideCount = 0;
spec->MiningStatus = BEGIN_WALL_DROP_RIGHT;
}
break;
case DONE_WAIT:
spec->mineaistate = MINE_DROP_ATTACK;
return TRUE;
break;
}
if(spec->MineDropNumber == minelayercorvettestatics->NumMinesInSide*minelayercorvettestatics->NumMinesInSide)
{
if(spec->mineforminfo != NULL)
{
spec->mineforminfo->FULL = TRUE;
spec->mineforminfo = NULL;
}
spec->mineaistate=MINE_DROP_ATTACK;
spec->MiningStatus = DONE_WAIT;
spec->MineDropNumber = 0;
return(TRUE); //finished Wall
}
return(FALSE);
}
/*-----------------------------------------------------------------------------
Name : sdLabelListLoad
Description : Load in a list of function pointers from a .MAP file.
Inputs : mapFile - mapfile to load in
Outputs :
Return :
----------------------------------------------------------------------------*/
void sdLabelListLoad(char *mapFile)
{
char readLine[256];
char textSegmentString[10];
char *string, *label, *module;
FILE *fp;
sdword nScanned;
udword textSegment = 0xffffffff;
udword segment, base, length;
sdfunctionlabel *newAlloc;
fp = fopen(mapFile, "rt");
if (fp == NULL)
{
dbgFatalf(DBG_Loc, "Cannot open map file '%s'.", mapFile);
}
printf("\nLoading MAP file '%s'", mapFile);
while (!feof(fp))
{
if (!fgets(readLine, 255, fp))
{
break;
}
if (sdNLabels >= sdNAllocated)
{
printf(".");
sdNAllocated += SD_LabelListInc;
newAlloc = memAlloc(sizeof(sdfunctionlabel) * sdNAllocated, "LabelList", 0);
if (sdFunctions != NULL)
{
memcpy(newAlloc, sdFunctions, sizeof(sdfunctionlabel) * sdNAllocated);
//memFree(sdFunctions);
}
sdFunctions = newAlloc;
}
if (strstr(readLine, " .text ") != NULL)
{ //definition of the code segment
dbgAssert(strstr(readLine, "CODE"));
dbgAssert(textSegment == 0xffffffff);
nScanned = sscanf(readLine, "%x:%x %xH", &segment, &base, &length);
dbgAssert(nScanned == 3);
minFunctionAddress = base;
maxFunctionAddress = base + length;
textSegment = segment;
dbgAssert(textSegment < 10);
sprintf(textSegmentString, "000%d:", textSegment);
}
else
{
if (textSegment != 0xffffffff)
{
if ((string = strtok(readLine, " \t\n")) != NULL)
{ //found anything at all
if (strstr(string, textSegmentString) == string)
{ //found segment/address
nScanned = sscanf(string, "%x:%x", &segment, &base);
if (nScanned == 2 && base >= minFunctionAddress && base <= maxFunctionAddress)
{
if ((string = strtok(NULL, " \t\n")) != NULL)
{ //found label
label = string;
if ((string = strtok(NULL, " \t\n")) != NULL)
{ //found preferred load address
if ((string = strtok(NULL, " \t\n")) != NULL)
{ //found 'f'
if ((string = strtok(NULL, " \t\n")) != NULL)
{ //found module name
module = string;
sdFunctions[sdNLabels].label = memAlloc(strlen(label) + strlen(module) + 2, "LabelModule", 0)
strcpy(sdFunctions[sdNLabels].label, label);
sdFunctions[sdNLabels].module = sdFunctions[sdNLabels].label + strlen(label) + 1;
strcpy(sdFunctions[sdNLabels].module, module);
sdFunctions[sdNLabels].address = base;
sdNLabels++;
}
}
}
}
}
}
}
}
}
}
if (textSegment == 0xffffffff || sdNLabels < 10)
{
dbgFatalf(DBG_Loc, "Could not load text segment from map file '%s'.", mapFile);
}
fclose(fp);
}
/*-----------------------------------------------------------------------------
Name : lightParseHSF
Description : parse a homeworld scene file for lighting info
Inputs : fileName - the name of the .hsf file, no extension or directory
Outputs : alters global variables
Return :
----------------------------------------------------------------------------*/
void lightParseHSF(char* fileName)
{
udword numLights = 1;
static char lastFileName[128];
if (fileName == NULL)
{
fileName = lastFileName;
}
else
{
memStrncpy(lastFileName, fileName, 127);
}
lightDefaultLightSet();
if (fileExists(fileName, 0))
{
HSFFileHeader* hsfHeader;
HSFLight* hsfLight;
ubyte* buf;
real32 ambient[4] = {0.2f, 0.2f, 0.2f, 1.0f};
sdword pos = sizeof(HSFFileHeader);
sdword fileSize = fileSizeGet(fileName, 0);
buf = memAlloc(fileSize, "lightParseHSF", 0);
fileLoad(fileName, buf, 0);
hsfHeader = (HSFFileHeader*)buf;
#if FIX_ENDIAN
hsfHeader->version = FIX_ENDIAN_INT_32( hsfHeader->version );
hsfHeader->nLights = FIX_ENDIAN_INT_32( hsfHeader->nLights );
#endif
numLights = 0;
while (pos <= (sdword)(fileSize - sizeof(HSFLight)))
{
lightinfo* linfo;
hsfLight = (HSFLight*)(buf + pos);
#if FIX_ENDIAN
hsfLight->type = FIX_ENDIAN_INT_32( hsfLight->type );
hsfLight->x = FIX_ENDIAN_FLOAT_32( hsfLight->x );
hsfLight->y = FIX_ENDIAN_FLOAT_32( hsfLight->y );
hsfLight->z = FIX_ENDIAN_FLOAT_32( hsfLight->z );
hsfLight->h = FIX_ENDIAN_FLOAT_32( hsfLight->h );
hsfLight->p = FIX_ENDIAN_FLOAT_32( hsfLight->p );
hsfLight->b = FIX_ENDIAN_FLOAT_32( hsfLight->b );
hsfLight->coneAngle = FIX_ENDIAN_FLOAT_32( hsfLight->coneAngle );
hsfLight->edgeAngle = FIX_ENDIAN_FLOAT_32( hsfLight->edgeAngle );
hsfLight->intensity = FIX_ENDIAN_FLOAT_32( hsfLight->intensity );
#endif
if (hsfLight->type != L_AmbientLight)
{
numLights++;
linfo = (numLights == 2) ? ¤tLight1 : currentLight;
//"L_DistantLight"
_inplace_glify((GLfloat*)&hsfLight->x);
linfo->position[0] = hsfLight->x;
linfo->position[1] = hsfLight->y;
linfo->position[2] = hsfLight->z;
linfo->position[3] = 0.0f;
/* if (hsfLight->intensity > 1.0f)
{
hsfLight->intensity = 1.0f;
}*/
linfo->ambient[0] = 0.3f * hsfLight->intensity * (real32)hsfLight->red / 255.0f;
linfo->ambient[1] = 0.3f * hsfLight->intensity * (real32)hsfLight->green / 255.0f;
linfo->ambient[2] = 0.3f * hsfLight->intensity * (real32)hsfLight->blue / 255.0f;
linfo->ambient[3] = 1.0f;
linfo->diffuse[0] = hsfLight->intensity * (real32)hsfLight->red / 255.0f;
linfo->diffuse[1] = hsfLight->intensity * (real32)hsfLight->green / 255.0f;
linfo->diffuse[2] = hsfLight->intensity * (real32)hsfLight->blue / 255.0f;
linfo->diffuse[3] = 1.0f;
linfo->specular[0] = 1.0f;
linfo->specular[1] = 1.0f;
linfo->specular[2] = 1.0f;
linfo->specular[3] = 1.0f;
}
else
{
sdword i;
//L_AmbientLight
ambient[0] = hsfLight->intensity * (real32)hsfLight->red / 255.0f;
ambient[1] = hsfLight->intensity * (real32)hsfLight->green / 255.0f;
ambient[2] = hsfLight->intensity * (real32)hsfLight->blue / 255.0f;
ambient[3] = 1.0f;
for (i = 0; i < 4; i++)
{
real32 lv = 2.0f * ambient[i];
if (lv > 1.0f) lv = 1.0f;
lightAmbient[i] = lv;
}
}
pos += sizeof(HSFLight);
}
memFree(buf);
strcpy(lightCurrentLighting, fileName);
}
// else
// {
// lightDefaultLightSet();
// }
lightSetNumLights(numLights);
}
void defensefightertargetbullet(Ship *ship, Bullet *bullettotarget)
{
DefenseFighterSpec *spec = (DefenseFighterSpec *)ship->ShipSpecifics;
DefenseFighterStatics *defensefighterstatics;
DefenseStruct *newdefensestruct;
Bullet *laser;
GunStatic *gunstatic;
Gun *gun;
ShipStaticInfo *shipstatic;
vector positionInWorldCoordSys,tempvec;
real32 floatDamage;
udword intDamage;
udword intVelocity;
udword intLength;
etgeffectstatic *stat;
etglod *etgLOD;
sdword LOD;
Effect *newEffect;
#ifndef HW_Release
/* dbgMessagef("B: %d %x %x %f %f %f %x %f %x",universe.univUpdateCounter,
bullettotarget->flags,
bullettotarget->owner,
bullettotarget->timelived,
bullettotarget->damage,
bullettotarget->damageFull,
bullettotarget->SpecialEffectFlag,
bullettotarget->BulletSpeed,
bullettotarget);
*/
#endif
gun = &ship->gunInfo->guns[0];
gunstatic = gun->gunstatic;
shipstatic = (ShipStaticInfo *)ship->staticinfo;
defensefighterstatics = (DefenseFighterStatics *) ((ShipStaticInfo *)(ship->staticinfo))->custstatinfo;
bitSet(bullettotarget->SpecialEffectFlag, 0x0002); //set the flag
laser = memAlloc(sizeof(Bullet),"Bullet",0);
memset(laser,0,sizeof(Bullet)); // for safety
laser->objtype = OBJ_BulletType;
laser->flags = 0;
laser->staticinfo = NULL;
ClearNode(laser->renderlink);
laser->currentLOD = ship->currentLOD;
laser->cameraDistanceSquared = ship->cameraDistanceSquared;
laser->soundType = gunstatic->gunsoundtype;
laser->bulletType = BULLET_Laser;
laser->owner = ship;
laser->gunowner = gun;
laser->target = NULL;
laser->bulletColor = etgBulletColor[shipstatic->shiprace][laser->soundType];
laser->bulletmass = 0.0f; //gunstatic->bulletmass;
laser->lengthmag = 600.0f;
laser->damage = frandombetween(defensefighterstatics->DamageReductionLow,
defensefighterstatics->DamageReductionHigh);
laser->timelived = 0.0f;
laser->totallifetime = 100.0f; //laser will only live for a sec anyways...
laser->SpecialEffectFlag = 0;
laser->traveldist = gunstatic->bulletlength;
laser->beamtraveldist = gunstatic->bulletlength;
//laser->posinfo.isMoving = TRUE;
//laser->posinfo.haventCalculatedDist = TRUE;
laser->DFGFieldEntryTime = 0.0f;
matMultiplyMatByVec(&positionInWorldCoordSys,&ship->rotinfo.coordsys,&gunstatic->position);
vecAdd(laser->posinfo.position,positionInWorldCoordSys,ship->posinfo.position);
vecSub(laser->lengthvec, bullettotarget->posinfo.position, laser->posinfo.position);
// heading
tempvec = laser->lengthvec;
vecNormalize(&tempvec);
//matMultiplyMatByVec(&gunheadingInWorldCoordSys, &ship->rotinfo.coordsys, &tempvec);
//laser->bulletheading = gunheadingInWorldCoordSys;
laser->bulletheading = tempvec;
matCreateCoordSysFromHeading(&laser->rotinfo.coordsys,&tempvec);
vecZeroVector(laser->posinfo.velocity);
//Laser effect...
floatDamage = (real32)laser->damage;
intDamage = TreatAsUdword(floatDamage);
intVelocity = TreatAsUdword(gunstatic->bulletspeed);
intLength = TreatAsUdword(gunstatic->bulletlength);
//create an effect for bullet, if applicable
etgLOD = etgGunEventTable[shipstatic->shiprace][gunstatic->gunsoundtype][EGT_GunBullet];//get pointer to bullet effect
//etgLOD = etgGunEventTable[0][gunstatic->gunsoundtype][EGT_GunBullet];//get pointer to bullet effect
//in future change back to proper one above...
if (etgLOD != NULL)
{
if (bullettotarget != NULL)
{
LOD = min(ship->currentLOD, bullettotarget->currentLOD);
}
else
{
LOD = ship->currentLOD;
}
if (LOD >= etgLOD->nLevels)
{
stat = NULL;
}
else
{
stat = etgLOD->level[LOD];
}
}
else
{
stat = NULL;
}
#if ETG_DISABLEABLE
if (stat != NULL && etgBulletEffectsEnabled && etgEffectsEnabled && !etgFrequencyExceeded(stat))
#else
if (stat != NULL && etgBulletEffectsEnabled && !etgFrequencyExceeded(stat))
#endif
{
laser->effect = etgEffectCreate(stat, laser, NULL, NULL, NULL, 1.0f, EAF_AllButNLips, 3, intDamage, intVelocity, intLength);
// univAddObjToRenderListIf((SpaceObj *)laser->effect,(SpaceObj *)ship); // add to render list if parent ship is in render list
//do length calculations :)
((real32 *)laser->effect->variable)[ETG_LengthVariable] =
fsqrt(vecMagnitudeSquared(laser->lengthvec));
}
else
{
laser->effect = NULL; //play no effect for this bullet
}
// laser->effect = NULL; //need for render...add later?
laser->hitEffect = etgGunEventTable[shipstatic->shiprace][bullettotarget->gunowner->gunstatic->gunsoundtype][EGT_BulletDestroyed];//get pointer to bullet effect
if (ship->soundevent.burstHandle < 0)
{
soundEventBurstFire(ship, gun);
}
etgLOD = etgGunEventTable[shipstatic->shiprace][gunstatic->gunsoundtype][EGT_GunFire];//get pointer to bullet effect
if (etgLOD != NULL)
{
LOD = ship->currentLOD;
if (LOD >= etgLOD->nLevels)
{
stat = NULL;
}
else
{
stat = etgLOD->level[LOD];
}
}
else
{
stat = NULL;
}
#if ETG_DISABLEABLE
if (stat != NULL && etgEffectsEnabled && etgFireEffectsEnabled && !etgFrequencyExceeded(stat))
#else
if (stat != NULL && etgFireEffectsEnabled && !etgFrequencyExceeded(stat))
#endif
{ //if there is a gun fire effect
if (RGLtype == SWtype)
{ //smaller fire effects in software
floatDamage *= etgSoftwareScalarFire;
intDamage = TreatAsUdword(floatDamage);
}
newEffect = etgEffectCreate(stat, laser, NULL, NULL, NULL, 1.0f, EAF_AllButNLips, 1, intDamage);
// univAddObjToRenderListIf((SpaceObj *)newEffect,(SpaceObj *)ship); // add to render list if parent ship is in render list
}
/*
//spawn bullet hitting effect
etgLOD = etgTractorBeamEffectTable[ship->shiprace];
//etgLOD = etgGunEventTable[shipstatic->shiprace][gunstatic->gunsoundtype][EGT_GunFire];//get pointer to bullet effect
if (etgLOD != NULL)
{
LOD = ship->currentLOD;
if (LOD >= etgLOD->nLevels)
{
stat = NULL;
}
else
{
stat = etgLOD->level[LOD];
}
}
else
{
stat = NULL;
}
#if ETG_DISABLEABLE
if (stat != NULL && etgEffectsEnabled)
#else
if (stat != NULL)
#endif
{ //if there is a gun fire effect
// size = etgEffectSize(stat->nParticleBlocks);//compute size of effect
size = stat->effectSize;
newEffect = memAlloc(size, "DefenseFHittingEffect", 0); //allocate the new effect
newEffect->objtype = OBJ_EffectType;
newEffect->flags = SOF_Rotatable | SOF_AttachVelocity | SOF_AttachPosition | SOF_AttachCoordsys;
newEffect->staticinfo = (StaticInfo *)stat;
ClearNode(newEffect->renderlink);
newEffect->currentLOD = LOD;
newEffect->cameraDistanceSquared = ship->cameraDistanceSquared;
newEffect->timeElapsed = 0.0f; //brand new heavies
floatDamage = 30.0f;
intDamage = TreatAsUdword(floatDamage);
newEffect->rotinfo.coordsys = bullettotarget->rotinfo.coordsys;
newEffect->posinfo.position = bullettotarget->posinfo.position; //start at same spot as bullet
newEffect->posinfo.velocity = bullettotarget->posinfo.velocity; //start at same spot as bullet
etgEffectCodeStart(stat, newEffect, 1, intDamage);//get the code a-runnin'
newEffect->posinfo.isMoving = FALSE;
newEffect->posinfo.haventCalculatedDist = TRUE;
univUpdateObjRotInfo((SpaceObjRot *)newEffect);
// newEffect->owner = NULL; // nothing owns this effect
newEffect->owner = (Ship *) bullettotarget;
listAddNode(&universe.SpaceObjList,&(newEffect->objlink),newEffect);
univAddObjToRenderListIf((SpaceObj *)newEffect,(SpaceObj *)ship); // add to render list if parent ship is in render list
}
*/
//Not sure If I need to add...
listAddNode(&universe.SpaceObjList,&(laser->objlink),laser);
listAddNode(&universe.BulletList,&(laser->bulletlink),laser);
univAddObjToRenderListIf((SpaceObj *)laser,(SpaceObj *)ship); // add to render list if parent ship is in render list
newdefensestruct = memAlloc(sizeof(DefenseStruct),"DS(DefenseStruct)",Pyrophoric);
newdefensestruct->bullet = bullettotarget;
newdefensestruct->CoolDown = FALSE;
newdefensestruct->CoolDownTime = 0.0f;
newdefensestruct->LaserDead = FALSE;
listAddNode(&spec->DefenseList,&newdefensestruct->bulletnode,newdefensestruct);
newdefensestruct->laser = laser;
if(bitTest(ship->flags,SOF_CloakGenField))
{
bitSet(ship->flags,SOF_DeCloaking);
bitClear(ship->flags,SOF_Cloaked);
bitClear(ship->flags,SOF_Cloaking);
}
}
/*-----------------------------------------------------------------------------
Name : madFileLoad
Description : Load in a .MAD mesh animation file
Inputs : fileName - name of file to load
Outputs :
Return : newly allocated animation data
Note : the string block for binding information is allocated as a
separate block of memory so it can be freed after all
animation binding is complete.
----------------------------------------------------------------------------*/
madheader *madFileLoad(char *fileName)
{
madheader header;
madheader *newHeader;
sdword index, j;
filehandle file;
sdword fileSize;
#ifdef _X86_64
char newFileName[80];
sprintf(newFileName, "%s.64",fileName);
fileName = newFileName;
#endif
dbgAssertOrIgnore(fileName != NULL);
fileSize = fileSizeGet(fileName, 0);
file = fileOpen(fileName, 0);
fileBlockRead(file, &header, madHeaderSize(0));
#if FIX_ENDIAN
header.version = FIX_ENDIAN_FLOAT_32( header.version );
header.stringBlockLength = FIX_ENDIAN_INT_32( header.stringBlockLength );
header.stringBlock = ( char *)FIX_ENDIAN_INT_32( ( udword )header.stringBlock );
header.length = FIX_ENDIAN_FLOAT_32( header.length );
header.framesPerSecond = FIX_ENDIAN_FLOAT_32( header.framesPerSecond );
header.nObjects = FIX_ENDIAN_INT_32( header.nObjects );
header.objPath = ( madobjpath *)FIX_ENDIAN_INT_32( ( udword )header.objPath );
header.nAnimations = FIX_ENDIAN_INT_32( header.nAnimations );
#endif
#if MAD_ERROR_CHECKING
if (strcmp(header.identifier, MAD_FileIdentifier) != 0)
{
dbgFatalf(DBG_Loc, "Invalid header in '%s'. Expected '%s', found '%s'.", fileName, MAD_FileIdentifier, header.identifier);
}
if (header.version != MAD_FileVersion)
{
dbgFatalf(DBG_Loc, "Invalid file version in '%s'. Expected %.2f, found %.2f", fileName, MAD_FileVersion, header.version);
}
if (header.nAnimations > MAD_MaxAnimations)
{
dbgFatalf(DBG_Loc, "Too many animations in '%s': %d", fileName, header.nAnimations);
}
#endif
newHeader = memAlloc(fileSize - header.stringBlockLength, "meshAnimation", NonVolatile);
*newHeader = header;
fileBlockRead(file, &newHeader->anim[0], fileSize - newHeader->stringBlockLength - madHeaderSize(0));
newHeader->stringBlock = memAlloc(newHeader->stringBlockLength, "madStringBlock", NonVolatile);//!!!should this be non volatile? I guess it depends on how soon the string block is freed, if ever.
fileBlockRead(file, newHeader->stringBlock, newHeader->stringBlockLength);
fileClose(file);
#if MAD_VERBOSE_LEVEL >= 2
dbgMessagef("madFileLoad: loaded %d animations for %d objects from '%s'", newHeader->nAnimations, newHeader->nObjects, fileName);
#endif
//loop through all the structures and fix up pointers
for (index = 0; index < newHeader->nAnimations; index++)
{ //fixup the name of all animations
#if FIX_ENDIAN
newHeader->anim[index].name = ( char *)FIX_ENDIAN_INT_32( ( memsize )newHeader->anim[index].name );
newHeader->anim[index].startTime = FIX_ENDIAN_FLOAT_32( newHeader->anim[index].startTime );
newHeader->anim[index].endTime = FIX_ENDIAN_FLOAT_32( newHeader->anim[index].endTime );
newHeader->anim[index].flags = FIX_ENDIAN_INT_32( newHeader->anim[index].flags );
#endif
newHeader->anim[index].name += (memsize)newHeader->stringBlock;
}
newHeader->objPath = (madobjpath *)((memsize)newHeader + (ubyte *)newHeader->objPath);
for (index = 0; index < newHeader->nObjects; index++)
{
#if FIX_ENDIAN
newHeader->objPath[index].name = ( char *)FIX_ENDIAN_INT_32( ( memsize )newHeader->objPath[index].name );
newHeader->objPath[index].nameCRC = FIX_ENDIAN_INT_16( newHeader->objPath[index].nameCRC );
newHeader->objPath[index].animationBits = FIX_ENDIAN_INT_32( newHeader->objPath[index].animationBits );
newHeader->objPath[index].nKeyframes = FIX_ENDIAN_INT_32( newHeader->objPath[index].nKeyframes );
newHeader->objPath[index].times = ( real32 *)FIX_ENDIAN_INT_32( ( udword )newHeader->objPath[index].times );
newHeader->objPath[index].parameters = ( tcb *)FIX_ENDIAN_INT_32( ( udword )newHeader->objPath[index].parameters );
#endif
newHeader->objPath[index].name += (memsize)newHeader->stringBlock;//fixup name
newHeader->objPath[index].nameCRC = crc16Compute((ubyte *)newHeader->objPath[index].name, strlen(newHeader->objPath[index].name));
newHeader->objPath[index].times = (real32 *)((memsize)newHeader + (ubyte *)newHeader->objPath[index].times);//fixup times pointers
newHeader->objPath[index].parameters = (tcb *)((memsize)newHeader + (ubyte *)newHeader->objPath[index].parameters);//fixup times pointers
for (j = 0; j < 6; j++)
{ //fixup the motion path array pointers
#if FIX_ENDIAN
newHeader->objPath[index].path[j] = ( real32 *)FIX_ENDIAN_INT_32( ( udword )newHeader->objPath[index].path[j] );
#endif
newHeader->objPath[index].path[j] = (real32 *)((memsize)newHeader + (ubyte *)newHeader->objPath[index].path[j]);
}
#if FIX_ENDIAN
for( j = 0; j < newHeader->objPath[index].nKeyframes; j++ )
{
int k = 0;
newHeader->objPath[index].times[j] = FIX_ENDIAN_FLOAT_32( newHeader->objPath[index].times[j] );
newHeader->objPath[index].parameters[j].tension = FIX_ENDIAN_FLOAT_32( newHeader->objPath[index].parameters[j].tension );
newHeader->objPath[index].parameters[j].continuity = FIX_ENDIAN_FLOAT_32( newHeader->objPath[index].parameters[j].continuity );
newHeader->objPath[index].parameters[j].bias = FIX_ENDIAN_FLOAT_32( newHeader->objPath[index].parameters[j].bias );
for( k = 0; k < 6; k++ )
{
newHeader->objPath[index].path[k][j] = FIX_ENDIAN_FLOAT_32( newHeader->objPath[index].path[k][j] );
}
}
#endif
}
return(newHeader);
}
int
main (
int argc,
char * argv[])
{
ArchMesh2 arch; /* Mesh dimensions */
ArchMesh2Dom dom; /* Initial domain */
C_MethType methtype; /* Bipartitioning method */
unsigned int termnbr; /* Number of terminal domains */
unsigned int termmax; /* Maximum terminal number */
unsigned int * termtab; /* Terminal numbers table */
unsigned int x0, y0, x1, y1;
int i;
errorProg ("amk_m2");
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
methtype = C_METHNESTED;
arch.c[0] = /* Preset mesh dimensions */
arch.c[1] = 1;
for (i = 0; i < C_FILENBR; i ++) /* Set default stream pointers */
C_fileTab[i].pntr = (C_fileTab[i].mode[0] == 'r') ? stdin : stdout;
for (i = 1; i < argc; i ++) { /* Loop for all option codes */
if ((argv[i][0] != '-') || (argv[i][1] == '\0') || (argv[i][1] == '.')) { /* If found a file name */
if (C_paraNum < 2) { /* If number of parameters not reached */
if ((arch.c[C_paraNum ++] = atoi (argv[i])) < 1) { /* Get the dimension */
errorPrint ("main: invalid dimension (\"%s\")", argv[i]);
return (1);
}
continue; /* Process the other parameters */
}
if (C_fileNum < C_FILEARGNBR) /* A file name has been given */
C_fileTab[C_fileNum ++].name = argv[i];
else {
errorPrint ("main: too many file names given");
return (1);
}
}
else { /* If found an option name */
switch (argv[i][1]) {
case 'M' : /* Use a built-in method */
case 'm' :
switch (argv[i][2]) {
case 'N' : /* Nested dissection */
case 'n' :
methtype = C_METHNESTED;
break;
case 'O' : /* One-way dissection */
case 'o' :
methtype = C_METHONEWAY;
break;
default :
errorPrint ("main: unprocessed option (\"%s\")", argv[i]);
return (1);
}
break;
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'V' :
fprintf (stderr, "amk_m2, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2004,2007,2008,2010 ENSEIRB, INRIA & CNRS, France\n");
fprintf (stderr, "This software is libre/free software under CeCILL-C -- see the user's manual for more information\n");
return (0);
default :
errorPrint ("main: unprocessed option (\"%s\")", argv[i]);
return (1);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
dom.c[0][0] = 0; /* Set the initial domain */
dom.c[0][1] = arch.c[0] - 1;
dom.c[1][0] = 0;
dom.c[1][1] = arch.c[1] - 1;
termnbr = arch.c[0] * arch.c[1]; /* Compute number of terminals */
termmax = 0; /* Maximum terminal value not known yet */
if ((termtab = (unsigned int *) memAlloc (termnbr * sizeof (unsigned int))) == NULL) { /* Allocate terminal array */
errorPrint ("main: out of memory");
return (1);
}
memset (termtab, -1, termnbr * sizeof (unsigned int)); /* Initilize mapping table */
C_termBipart (&arch, &dom, 1, termtab, &termmax, /* Compute terminal numbers */
(methtype == C_METHNESTED) ? archMesh2DomBipart : C_methBipartOne);
fprintf (C_filepntrarcout, "deco\n0\n%u\t%u\n", /* Print file header */
termnbr, /* Print number of terminal domains */
termmax); /* Print biggest terminal value */
for (i = 0; i < termnbr; i ++) /* For all terminals */
fprintf (C_filepntrarcout, "%u\t1\t%u\n", /* Print terminal data */
i, termtab[i]);
for (y0 = 0; y0 < arch.c[1]; y0 ++) { /* For all vertices */
for (x0 = 0; x0 < arch.c[0]; x0 ++) {
for (y1 = 0; y1 <= y0; y1 ++) { /* Compute distance to smaller vertices */
for (x1 = 0; (x1 < arch.c[0]) && ((y1 < y0) || (x1 < x0)); x1 ++)
fprintf (C_filepntrarcout,
((x1 == 0) && (y1 == 0)) ? "%u" : " %u",
C_termDist (x0, y0, x1, y1));
}
fprintf (C_filepntrarcout, "\n");
}
}
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
memFree (termtab); /* Free terminal number array */
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
int main (int argc, char *argv[])
{
char * inputfile; // job dispatch file
FILE * inputliststream;
PcbPtr inputqueue = NULL; // input queue buffer
PcbPtr fbqueue[N_FB_QUEUES]; // feedback queues
PcbPtr currentprocess = NULL; // current process
PcbPtr process = NULL; // working pcb pointer
int timer = 0; // dispatcher timer
int quantum = QUANTUM; // current time-slice quantum
int i; // working index
// 0. Parse command line
if (argc == 2) inputfile = argv[1];
else PrintUsage (stderr, argv[0]);
// 1. Initialize dispatcher queues;
for (i = 0; i < N_FB_QUEUES; fbqueue[i++] = NULL);
// 2. Fill dispatcher queue from dispatch list file;
if (!(inputliststream = fopen(inputfile, "r"))) { // open it
SysErrMsg("could not open dispatch list file:", inputfile);
exit(2);
}
while (!feof(inputliststream)) { // put processes into input_queue
process = createnullPcb();
if (fscanf(inputliststream,"%d, %d, %d, %d, %d, %d, %d, %d",
&(process->arrivaltime), &(process->priority),
&(process->remainingcputime), &(process->mbytes),
&(process->req.printers), &(process->req.scanners),
&(process->req.modems), &(process->req.cds)) != 8) {
free(process);
continue;
}
process->status = PCB_INITIALIZED;
inputqueue = enqPcb(inputqueue, process);
}
// 3. Start dispatcher timer;
// (already set to zero above)
//initialize memory
MabPtr memall = createnullMab(1024);
//split memory into "protected" Real Time process memory and User Memory
MabPtr rtmem = memSplit(memall, 64);
MabPtr mem = rtmem->next; //work with "mem" as user memory area
mem->justused = 1; //initialize, the "justused" represents the most recently used, and the algorithm assumes one exists no matter what
PcbPtr feedbackpending = NULL; // processes waiting for memory
// 4. While there's anything in any of the queues or there is a currently running process:
while (inputqueue || (CheckQueues(fbqueue) >= 0) || currentprocess ) {
// i. Unload any pending processes from the input queue:
// While (head-of-input-queue.arrival-time <= dispatcher timer)
// dequeue process from input queue and and enqueue on feebackpending queue
while (inputqueue && inputqueue->arrivaltime <= timer) {
process = deqPcb(&inputqueue); // dequeue process
process->status = PCB_READY; // set pcb ready
process->priority = 0; // override any priority
feedbackpending = enqPcb(feedbackpending, process);
// & put on queue
}
PcbPtr nextprocess = feedbackpending;
//unload pending processes from user job queue:
//while (feedbackpending->mbytes is free somewhere in user mem:
while(feedbackpending && memChk(mem, feedbackpending->mbytes)){
nextprocess = deqPcb(&feedbackpending); // dequeue process from user job queue
nextprocess->memoryblock = memAlloc(mem, nextprocess->mbytes); // allocate memory to the process
nextprocess->priority = 0;
fbqueue[nextprocess->priority] = enqPcb(fbqueue[nextprocess->priority], nextprocess);
}
puts("got it");
// iii. If a process is currently running;
if (currentprocess) {
currentprocess->remainingcputime -= quantum;
if (currentprocess->remainingcputime <= 0) {
terminatePcb(currentprocess);
memFree(currentprocess->memoryblock);
free(currentprocess);
currentprocess = NULL;
// c. else if other processes are waiting in feedback queues:
} else if (CheckQueues(fbqueue) >= 0) {
suspendPcb(currentprocess);
if (++(currentprocess->priority) >= N_FB_QUEUES)
currentprocess->priority = N_FB_QUEUES - 1;
fbqueue[currentprocess->priority] =
enqPcb(fbqueue[currentprocess->priority], currentprocess);
currentprocess = NULL;
}
}
// iv. If no process currently running && feedback queues are not empty:
if (!currentprocess && (i = CheckQueues(fbqueue)) >= 0) {
currentprocess = deqPcb(&fbqueue[i]);
startPcb(currentprocess);
}
// v. sleep for quantum;
quantum = currentprocess && currentprocess->remainingcputime < QUANTUM ?
currentprocess->remainingcputime :
!(currentprocess) ? 1 : QUANTUM;
sleep(quantum);
timer += quantum;
}
exit (0);
}
void Rectangle::alloc()
{
assert( m_obj == 0 );
m_obj = memAlloc( sizeof( GdkRectangle ) );
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Num vnodnbr; /* Number of nodes */
SCOTCH_Mesh meshdat; /* Source graph */
SCOTCH_Ordering ordedat; /* Graph ordering */
SCOTCH_Num * permtab; /* Permutation array */
SCOTCH_Strat stradat; /* Ordering strategy */
SCOTCH_Num straval;
char * straptr;
int flagval;
Clock runtime[2]; /* Timing variables */
int i, j;
errorProg ("mord");
intRandInit ();
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
flagval = C_FLAGNONE; /* Default behavior */
straval = 0; /* No strategy flags */
straptr = NULL;
SCOTCH_stratInit (&stradat);
for (i = 0; i < C_FILENBR; i ++) /* Set default stream pointers */
C_fileTab[i].pntr = (C_fileTab[i].mode[0] == 'r') ? stdin : stdout;
for (i = 1; i < argc; i ++) { /* Loop for all option codes */
if ((argv[i][0] != '-') || (argv[i][1] == '\0') || (argv[i][1] == '.')) { /* If found a file name */
if (C_fileNum < C_FILEARGNBR) /* File name has been given */
C_fileTab[C_fileNum ++].name = argv[i];
else {
errorPrint ("main: too many file names given");
return (1);
}
}
else { /* If found an option name */
switch (argv[i][1]) {
case 'C' :
case 'c' : /* Strategy selection parameters */
for (j = 2; argv[i][j] != '\0'; j ++) {
switch (argv[i][j]) {
case 'B' :
case 'b' :
straval |= SCOTCH_STRATBALANCE;
break;
case 'Q' :
case 'q' :
straval |= SCOTCH_STRATQUALITY;
break;
case 'S' :
case 's' :
straval |= SCOTCH_STRATSPEED;
break;
case 'T' :
case 't' :
straval |= SCOTCH_STRATSAFETY;
break;
default :
errorPrint ("main: invalid strategy selection option (\"%c\")", argv[i][j]);
}
}
break;
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'M' : /* Output separator mapping */
case 'm' :
flagval |= C_FLAGMAPOUT;
if (argv[i][2] != '\0')
C_filenamemapout = &argv[i][2];
break;
case 'O' : /* Ordering strategy */
case 'o' :
straptr = &argv[i][2];
SCOTCH_stratExit (&stradat);
SCOTCH_stratInit (&stradat);
if ((SCOTCH_stratMeshOrder (&stradat, straptr)) != 0) {
errorPrint ("main: invalid ordering strategy");
return (1);
}
break;
case 'V' :
fprintf (stderr, "mord, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2004,2007,2008,2010 ENSEIRB, INRIA & CNRS, France\n");
fprintf (stderr, "This software is libre/free software under CeCILL-C -- see the user's manual for more information\n");
return (0);
break;
case 'v' : /* Output control info */
for (j = 2; argv[i][j] != '\0'; j ++) {
switch (argv[i][j]) {
case 'S' :
case 's' :
flagval |= C_FLAGVERBSTR;
break;
case 'T' :
case 't' :
flagval |= C_FLAGVERBTIM;
break;
default :
errorPrint ("main: unprocessed parameter \"%c\" in \"%s\"",
argv[i][j], argv[i]);
return (1);
}
}
break;
default :
errorPrint ("main: unprocessed option (\"%s\")", argv[i]);
return (1);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
clockInit (&runtime[0]);
clockStart (&runtime[0]);
SCOTCH_meshInit (&meshdat); /* Create mesh structure */
SCOTCH_meshLoad (&meshdat, C_filepntrsrcinp, -1); /* Read source mesh */
SCOTCH_meshSize (&meshdat, NULL, &vnodnbr, NULL); /* Get number of nodes */
if (straval != 0) {
if (straptr != NULL)
errorPrint ("main: options '-c' and '-o' are exclusive");
SCOTCH_stratMeshOrderBuild (&stradat, straval, 0.1);
}
clockStop (&runtime[0]); /* Get input time */
clockInit (&runtime[1]);
clockStart (&runtime[1]);
if ((permtab = (SCOTCH_Num *) memAlloc (vnodnbr * sizeof (SCOTCH_Num))) == NULL) {
errorPrint ("main: out of memory");
return (1);
}
SCOTCH_meshOrderInit (&meshdat, &ordedat, permtab, NULL, NULL, NULL, NULL); /* Create ordering */
SCOTCH_meshOrderCompute (&meshdat, &ordedat, &stradat); /* Perform ordering */
clockStop (&runtime[1]); /* Get ordering time */
#ifdef SCOTCH_DEBUG_ALL
if (SCOTCH_meshOrderCheck (&meshdat, &ordedat) != 0)
return (1);
#endif /* SCOTCH_DEBUG_ALL */
clockStart (&runtime[0]);
SCOTCH_meshOrderSave (&meshdat, &ordedat, C_filepntrordout); /* Write ordering */
if (flagval & C_FLAGMAPOUT) /* If mapping wanted */
SCOTCH_meshOrderSaveMap (&meshdat, &ordedat, C_filepntrmapout); /* Write mapping */
clockStop (&runtime[0]); /* Get output time */
if (flagval & C_FLAGVERBSTR) {
fprintf (C_filepntrlogout, "S\tStrat=");
SCOTCH_stratSave (&stradat, C_filepntrlogout);
putc ('\n', C_filepntrlogout);
}
if (flagval & C_FLAGVERBTIM) {
fprintf (C_filepntrlogout, "T\tOrder\t\t%g\nT\tI/O\t\t%g\nT\tTotal\t\t%g\n",
(double) clockVal (&runtime[1]),
(double) clockVal (&runtime[0]),
(double) clockVal (&runtime[0]) +
(double) clockVal (&runtime[1]));
}
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
SCOTCH_meshOrderExit (&meshdat, &ordedat);
SCOTCH_stratExit (&stradat);
SCOTCH_meshExit (&meshdat);
memFree (permtab);
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
/*-----------------------------------------------------------------------------
Name : transAlloc
Description : wrapper for calling from C++
Inputs :
Outputs :
Return :
ASSERT : memAlloc returns 16 byte aligned data, or multiple of
----------------------------------------------------------------------------*/
void* transAlloc(int n)
{
return (void*)memAlloc(n, "Katmai mem", NonVolatile);
}
static GLUvertex *allocVertex()
{
return (GLUvertex *)memAlloc( sizeof( GLUvertex ));
}
int
main (
int argc,
char * argv[])
{
SCOTCH_Strat bipastrat; /* Bipartitioning strategy */
SCOTCH_Arch archdat; /* Target (terminal) architecture */
SCOTCH_Graph grafdat; /* Source graph to turn into architecture */
SCOTCH_Num vertnbr; /* Number of vertices in graph */
SCOTCH_Num * vlbltab; /* Pointer to vertex label array, if present */
SCOTCH_Num listnbr; /* Size of list array */
SCOTCH_Num * listtab; /* Pointer to list array */
C_VertSort * sorttab; /* Vertex label sort area */
SCOTCH_Num baseval;
SCOTCH_Num vertnum;
SCOTCH_Num listnum;
int flag; /* Process flags */
int i;
errorProg ("amk_grf");
intRandInit ();
if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */
usagePrint (stdout, C_usageList);
return (0);
}
flag = C_FLAGNONE;
SCOTCH_stratInit (&bipastrat);
for (i = 0; i < C_FILENBR; i ++) /* Set default stream pointers */
C_fileTab[i].pntr = (C_fileTab[i].mode[0] == 'r') ? stdin : stdout;
for (i = 1; i < argc; i ++) { /* Loop for all option codes */
if ((argv[i][0] != '-') || (argv[i][1] == '\0') || (argv[i][1] == '.')) { /* If found a file name */
if (C_fileNum < C_FILEARGNBR) /* File name has been given */
C_fileTab[C_fileNum ++].name = argv[i];
else {
errorPrint ("main: too many file names given");
return (1);
}
}
else { /* If found an option name */
switch (argv[i][1]) {
case 'B' : /* Bipartitioning strategy */
case 'b' :
SCOTCH_stratExit (&bipastrat);
SCOTCH_stratInit (&bipastrat);
if ((SCOTCH_stratGraphBipart (&bipastrat, &argv[i][2])) != 0) {
errorPrint ("main: invalid bipartitioning strategy");
return (1);
}
break;
case 'H' : /* Give the usage message */
case 'h' :
usagePrint (stdout, C_usageList);
return (0);
case 'L' : /* Input vertex list */
case 'l' :
flag |= C_FLAGVRTINP;
if (argv[i][2] != '\0')
C_filenamevrtinp = &argv[i][2];
break;
case 'V' :
fprintf (stderr, "amk_grf, version " SCOTCH_VERSION_STRING "\n");
fprintf (stderr, "Copyright 2004,2007,2008,2010 ENSEIRB, INRIA & CNRS, France\n");
fprintf (stderr, "This software is libre/free software under CeCILL-C -- see the user's manual for more information\n");
return (0);
default :
errorPrint ("main: unprocessed option (\"%s\")", argv[i]);
return (1);
}
}
}
fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */
SCOTCH_graphInit (&grafdat); /* Create graph structure */
SCOTCH_graphLoad (&grafdat, C_filepntrgrfinp, -1, 0); /* Load source graph */
SCOTCH_graphData (&grafdat, &baseval, &vertnbr, NULL, NULL, NULL, /* Get graph data */
&vlbltab, NULL, NULL, NULL);
listnbr = 0; /* Initialize vertex list */
listtab = NULL;
if (flag & C_FLAGVRTINP) { /* If list of vertices provided */
if ((intLoad (C_filepntrvrtinp, &listnbr) != 1) || /* Read list size */
(listnbr < 0) ||
(listnbr > vertnbr)) {
errorPrint ("main: bad list input (1)");
return (1);
}
if ((listtab = (SCOTCH_Num *) memAlloc (vertnbr * sizeof (SCOTCH_Num) + 1)) == NULL) {
errorPrint ("main: out of memory (1)");
return (1);
}
for (vertnum = 0; vertnum < vertnbr; vertnum ++) { /* Read list data */
if (intLoad (C_filepntrvrtinp, &listtab[vertnum]) != 1) {
errorPrint ("main: bad list input (2)");
return (1);
}
}
intSort1asc1 (listtab, vertnbr);
for (vertnum = 0; vertnum < vertnbr - 1; vertnum ++) { /* Search for duplicates */
if (listtab[vertnum] == listtab[vertnum + 1]) {
errorPrint ("main: duplicate list labels");
memFree (listtab);
return (1);
}
}
if (vlbltab != NULL) { /* If graph has vertex labels */
if ((sorttab = (C_VertSort *) memAlloc (vertnbr * sizeof (C_VertSort))) == NULL) {
errorPrint ("main: out of memory (2)");
memFree (listtab);
return (1);
}
for (vertnum = 0; vertnum < vertnbr; vertnum ++) { /* Initialize sort area */
sorttab[vertnum].labl = vlbltab[vertnum];
sorttab[vertnum].num = vertnum;
}
intSort2asc1 (sorttab, vertnbr); /* Sort by ascending labels */
for (listnum = 0, vertnum = 0; listnum < listnbr; listnum ++) { /* For all labels in list */
while ((vertnum < vertnbr) && (sorttab[vertnum].labl < listtab[listnum]))
vertnum ++; /* Search vertex graph with corresponding label */
if ((vertnum >= vertnbr) || /* If label not found */
(sorttab[vertnum].labl > listtab[listnum])) {
errorPrint ("main: list label not in graph (" SCOTCH_NUMSTRING ")", (SCOTCH_Num) listtab[listnum]);
memFree (sorttab);
memFree (listtab);
return (1);
}
listtab[listnum] = sorttab[vertnum ++].num; /* Replace label by number */
}
memFree (sorttab); /* Free sort area */
}
}
SCOTCH_archInit (&archdat); /* Initialize target architecture */
SCOTCH_archBuild (&archdat, &grafdat, listnbr, listtab, &bipastrat); /* Compute architecture */
SCOTCH_archSave (&archdat, C_filepntrtgtout); /* Write target architecture */
fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */
SCOTCH_graphExit (&grafdat); /* Free target graph */
SCOTCH_archExit (&archdat); /* Free target architecture */
SCOTCH_stratExit (&bipastrat); /* Free strategy string */
if (listtab != NULL) /* If vertex list provided */
memFree (listtab); /* Free it */
#ifdef COMMON_PTHREAD
pthread_exit ((void *) 0); /* Allow potential (un)compression tasks to complete */
#endif /* COMMON_PTHREAD */
return (0);
}
void DDDFrigateHousekeep(Ship *ship)
{
DDDFrigateSpec *spec = (DDDFrigateSpec *)ship->ShipSpecifics;
DroneSpec *dronespec;
DDDFrigateStatics *dddstat = ((ShipStaticInfo *)(ship->staticinfo))->custstatinfo;
real32 regeneraterate = (spec->DDDstate == DDDSTATE_ALLINSIDE) ? dddstat->internalRegenerateRate : dddstat->externalRegenerateRate;
if ((universe.totaltimeelapsed - spec->lasttimeRegenerated) > regeneraterate)
{
udword i;
spec->lasttimeRegenerated = universe.totaltimeelapsed;
// regenerate a drone, if one has been destroyed
for (i=0;i<MAX_NUM_DRONES;i++)
{
if (spec->DronePtrs[i] == NULL)
{
// found a dead drone, so let's create a new one.
spec->DronePtrs[i] = CreateDroneInside(ship,i);
switch (spec->DDDstate)
{
case DDDSTATE_ALLINSIDE: // all inside, so don't have to do anything
case DDDSTATE_DOCKTHEM: // docking, so no need to launch and then dock
case DDDSTATE_DOCKING: // docking, so no need to launch and then dock
case DDDSTATE_LAUNCHTHEM: // going to launch everything, so no action needed
break;
case DDDSTATE_LAUNCHING:
// we just created a drone, which is inside.
// we need to prepare it so it can launch too.
LaunchDrone(ship,spec->DronePtrs[i]);
break;
case DDDSTATE_ALLOUTSIDE:
spec->DDDstate = DDDSTATE_LAUNCHTHEM; // launch regenerated drone
break;
}
break;
}
}
}
switch (spec->DDDstate)
{
case DDDSTATE_ALLINSIDE:
break;
case DDDSTATE_LAUNCHTHEM:
{
// for all the drones inside,
ShipsInsideMe *shipsInsideMe = ship->shipsInsideMe;
Node *node = shipsInsideMe->insideList.head;
InsideShip *insideShip;
if (node == NULL)
{
// no Drones, so just return
spec->DDDstate = DDDSTATE_ALLINSIDE;
return;
}
soundEvent(ship, Ship_DroneLaunch);
do
{
insideShip = (InsideShip *)listGetStructOfNode(node);
LaunchDrone(ship,insideShip->ship);
node = node->next;
} while (node != NULL);
spec->DDDstate = DDDSTATE_LAUNCHING;
}
break;
case DDDSTATE_LAUNCHING:
{
// for all of the DDD's Drones,
udword i;
Ship *drone;
bool alllaunched = TRUE;
for (i=0;i<MAX_NUM_DRONES;i++)
{
drone = spec->DronePtrs[i];
if (drone != NULL)
{
dronespec = (DroneSpec *)drone->ShipSpecifics;
dbgAssert(dronespec->droneNumber == i);
switch (dronespec->droneState)
{
case DRONESTATE_LAUNCHING:
alllaunched = FALSE;
if (LaunchShipFromDDDF(drone,ship))
{
RemoveShipFromLaunching(drone);
dronespec->droneState = DRONESTATE_LAUNCHED;
}
break;
case DRONESTATE_LAUNCHED:
break;
}
}
}
if (alllaunched)
{
SelectCommand *droneselect;
SelectCommand selectone;
sdword numShipsToLaunch = 0;
droneselect = memAlloc(sizeofSelectCommand(MAX_NUM_DRONES),"DroneSelLaunch",0);
for (i=0;i<MAX_NUM_DRONES;i++)
{
drone = spec->DronePtrs[i];
if (drone != NULL)
{
dbgAssert(((DroneSpec *)drone->ShipSpecifics)->droneState == DRONESTATE_LAUNCHED);
droneselect->ShipPtr[numShipsToLaunch++] = drone;
}
}
if (numShipsToLaunch == 0)
{
memFree(droneselect); // all ships are launched, but there are none so consider them inside
spec->DDDstate = DDDSTATE_ALLINSIDE;
return;
}
droneselect->numShips = numShipsToLaunch;
dbgAssert(numShipsToLaunch <= MAX_NUM_DRONES);
selectone.ShipPtr[0] = ship;
selectone.numShips = 1;
// put all ships in formation, and guarding DDDF
clFormation(&universe.mainCommandLayer,droneselect,SPHERE_FORMATION);
clProtect(&universe.mainCommandLayer,droneselect,&selectone);
memFree(droneselect);
spec->DDDstate = DDDSTATE_ALLOUTSIDE;
}
}
break;
case DDDSTATE_ALLOUTSIDE:
break;
case DDDSTATE_DOCKTHEM:
{
sdword i;
Ship *drone;
SelectCommand *droneselect;
sdword numShipsToDock = 0;
DroneSpec *dronespec;
droneselect = memAlloc(sizeofSelectCommand(MAX_NUM_DRONES),"DroneSelection",0);
// remove drones from doing other stuff
for (i=0;i<MAX_NUM_DRONES;i++)
{
drone = spec->DronePtrs[i];
if (drone != NULL)
{
dbgAssert(((DroneSpec *)drone->ShipSpecifics)->droneState == DRONESTATE_LAUNCHED);
droneselect->ShipPtr[numShipsToDock++] = drone;
}
}
if (numShipsToDock == 0)
{
memFree(droneselect);
spec->DDDstate = DDDSTATE_ALLINSIDE;
return;
}
droneselect->numShips = numShipsToDock;
dbgAssert(numShipsToDock <= MAX_NUM_DRONES);
// remove ships from sphere formation and protecting
RemoveShipsFromDoingStuff(&universe.mainCommandLayer,droneselect);
// initialize each drone for docking
for (i=0;i<numShipsToDock;i++)
{
drone = droneselect->ShipPtr[i];
dronespec = (DroneSpec *)drone->ShipSpecifics;
dockPrepareDroneForDocking(drone,ship);
dronespec->droneState = DRONESTATE_DOCKING;
}
memFree(droneselect);
spec->DDDstate = DDDSTATE_DOCKING;
}
break;
case DDDSTATE_DOCKING:
{
sdword i;
Ship *drone;
DroneSpec *dronespec;
bool allDocked = TRUE;
// for each drone in DRONESTATE_Docking, call DroneDocksAtDDDF
for (i=0;i<MAX_NUM_DRONES;i++)
{
drone = spec->DronePtrs[i];
if (drone != NULL)
{
dronespec = (DroneSpec *)drone->ShipSpecifics;
if (dronespec->droneState == DRONESTATE_DOCKING)
{
allDocked = FALSE;
if (DroneDocksAtDDDF(drone,ship))
{
soundEvent(ship, Ship_DroneAcquire);
RemoveShipFromDocking(drone);
dronespec->droneState = DRONESTATE_DORMANT;
}
}
}
}
if (allDocked)
{
spec->DDDstate = DDDSTATE_ALLINSIDE;
}
}
break;
}
}
SCOTCH_Geom *
SCOTCH_geomAlloc ()
{
return ((SCOTCH_Geom *) memAlloc (sizeof (SCOTCH_Geom)));
}
