int TurretControl::execute_Target(int port,DeviceCmd cmd,const Pose::vec &vec)
{
if(port==portTarget)
{
if(cmd==dcmdTarget_set || cmd==dcmdTarget_update)
{
target=vec;
flagSet(lstate,Aim|Shoot,true);
}
else if(cmd==dcmdTarget_reset) // reset target
{
stop();
}
return dcmdOk;
}
return 0;
}
static bool UBLOX_parse_gps(void)
{
switch (_msg_id) {
case MSG_POSLLH:
//i2c_dataset.time = _buffer.posllh.time;
gps.coord[LON] = _buffer.posllh.longitude;
gps.coord[LAT] = _buffer.posllh.latitude;
gps.altitude = _buffer.posllh.altitude_msl / 10; // alt in cm
if (next_fix)
flagSet(FLAG_GPS_FIX);
else
flagClear(FLAG_GPS_FIX);
_new_position = true;
break;
case MSG_STATUS:
next_fix = (_buffer.status.fix_status & NAV_STATUS_FIX_VALID) && (_buffer.status.fix_type == FIX_3D);
if (!next_fix)
flagClear(FLAG_GPS_FIX);
break;
case MSG_SOL:
next_fix = (_buffer.solution.fix_status & NAV_STATUS_FIX_VALID) && (_buffer.solution.fix_type == FIX_3D);
if (!next_fix)
flagClear(FLAG_GPS_FIX);
gps.numSat = _buffer.solution.satellites;
gps.hdop = _buffer.solution.position_DOP;
// debug[3] = GPS_hdop;
break;
case MSG_VELNED:
// speed_3d = _buffer.velned.speed_3d; // cm/s
gps.speed = _buffer.velned.speed_2d / 10; // cm/s -> 0.1 m/s
gps.ground_course = (uint16_t) (_buffer.velned.heading_2d / 10000); // Heading 2D deg * 100000 rescaled to deg * 10
_new_speed = true;
break;
default:
return false;
}
// we only return true when we get new position and speed data
// this ensures we don't use stale data
if (_new_position && _new_speed) {
_new_speed = _new_position = false;
return true;
}
return false;
}
V8CustomElementLifecycleCallbacks::V8CustomElementLifecycleCallbacks(ScriptState* scriptState, v8::Local<v8::Object> prototype, v8::MaybeLocal<v8::Function> created, v8::MaybeLocal<v8::Function> attached, v8::MaybeLocal<v8::Function> detached, v8::MaybeLocal<v8::Function> attributeChanged)
: CustomElementLifecycleCallbacks(flagSet(attached, detached, attributeChanged))
, ContextLifecycleObserver(scriptState->executionContext())
, m_scriptState(scriptState)
, m_prototype(scriptState->isolate(), prototype)
, m_created(scriptState->isolate(), created)
, m_attached(scriptState->isolate(), attached)
, m_detached(scriptState->isolate(), detached)
, m_attributeChanged(scriptState->isolate(), attributeChanged)
{
m_prototype.setWeak(&m_prototype, weakCallback<v8::Object>);
#define MAKE_WEAK(Var, _) \
if (!m_##Var.isEmpty()) \
m_##Var.setWeak(&m_##Var, weakCallback<v8::Function>);
CALLBACK_LIST(MAKE_WEAK)
#undef MAKE_WEAK
}
V8CustomElementLifecycleCallbacks::V8CustomElementLifecycleCallbacks(ScriptExecutionContext* scriptExecutionContext, v8::Handle<v8::Object> prototype, v8::Handle<v8::Function> created, v8::Handle<v8::Function> enteredView, v8::Handle<v8::Function> leftView, v8::Handle<v8::Function> attributeChanged)
: CustomElementLifecycleCallbacks(flagSet(enteredView, leftView, attributeChanged))
, ActiveDOMCallback(scriptExecutionContext)
, m_world(DOMWrapperWorld::current())
, m_prototype(toIsolate(scriptExecutionContext), prototype)
, m_created(toIsolate(scriptExecutionContext), created)
, m_enteredView(toIsolate(scriptExecutionContext), enteredView)
, m_leftView(toIsolate(scriptExecutionContext), leftView)
, m_attributeChanged(toIsolate(scriptExecutionContext), attributeChanged)
, m_owner(0)
{
m_prototype.makeWeak(&m_prototype, weakCallback<v8::Object>);
#define MAKE_WEAK(Var, _) \
if (!m_##Var.isEmpty()) \
m_##Var.makeWeak(&m_##Var, weakCallback<v8::Function>);
CALLBACK_LIST(MAKE_WEAK)
#undef MAKE_WEAK
}
V8CustomElementLifecycleCallbacks::V8CustomElementLifecycleCallbacks(ExecutionContext* executionContext, v8::Handle<v8::Object> prototype, v8::Handle<v8::Function> created, v8::Handle<v8::Function> attached, v8::Handle<v8::Function> detached, v8::Handle<v8::Function> attributeChanged)
: CustomElementLifecycleCallbacks(flagSet(attached, detached, attributeChanged))
, ContextLifecycleObserver(executionContext)
, m_owner(0)
, m_scriptState(NewScriptState::current(toIsolate(executionContext)))
, m_prototype(m_scriptState->isolate(), prototype)
, m_created(m_scriptState->isolate(), created)
, m_attached(m_scriptState->isolate(), attached)
, m_detached(m_scriptState->isolate(), detached)
, m_attributeChanged(m_scriptState->isolate(), attributeChanged)
{
m_prototype.setWeak(&m_prototype, weakCallback<v8::Object>);
#define MAKE_WEAK(Var, _) \
if (!m_##Var.isEmpty()) \
m_##Var.setWeak(&m_##Var, weakCallback<v8::Function>);
CALLBACK_LIST(MAKE_WEAK)
#undef MAKE_WEAK
}
static bool GPS_NMEA_newFrame(char c)
{
uint8_t frameOK = 0;
static uint8_t param = 0, offset = 0, parity = 0;
static char string[15];
static uint8_t checksum_param, frame = 0;
if (c == '$')
{
param = 0;
offset = 0;
parity = 0;
}
else if (c == ',' || c == '*')
{
string[offset] = 0;
if (param == 0)
{ //frame identification
frame = 0;
if (string[0] == 'G' && string[1] == 'P' && string[2] == 'G'
&& string[3] == 'G' && string[4] == 'A')
frame = FRAME_GGA;
if (string[0] == 'G' && string[1] == 'P' && string[2] == 'R'
&& string[3] == 'M' && string[4] == 'C')
frame = FRAME_RMC;
}
else if (frame == FRAME_GGA)
{
if (param == 2)
{
gps.coord[LAT] = GPS_coord_to_degrees(string);
}
else if (param == 3 && string[0] == 'S')
gps.coord[LAT] = -gps.coord[LAT];
else if (param == 4)
{
gps.coord[LON] = GPS_coord_to_degrees(string);
}
else if (param == 5 && string[0] == 'W')
gps.coord[LON] = -gps.coord[LON];
else if (param == 6)
{
if (string[0] > '0')
flagSet(FLAG_GPS_FIX);
else
flagClear(FLAG_GPS_FIX);
}
else if (param == 7)
{
gps.numSat = grab_fields(string, 0);
}
else if (param == 9)
{
gps.altitude = grab_fields(string, 0); // altitude in meters added by Mis
}
}
else if (frame == FRAME_RMC)
{
if (param == 7)
{
gps.speed = (grab_fields(string, 1) * 5144L) / 1000L; // speed in cm/s added by Mis
}
else if (param == 8)
{
gps.ground_course = grab_fields(string, 1); // ground course deg * 10
}
}
param++;
offset = 0;
if (c == '*')
checksum_param = 1;
else
parity ^= c;
}
else if (c == '\r' || c == '\n')
{
if (checksum_param)
{ // parity checksum
uint8_t checksum = hex_c(string[0]);
checksum <<= 4;
checksum += hex_c(string[1]);
if (checksum == parity)
frameOK = 1;
}
checksum_param = 0;
}
else
{
if (offset < 15)
string[offset++] = c;
if (!checksum_param)
parity ^= c;
}
return frameOK && (frame == FRAME_GGA);
}
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.bbalglbval = orggrafptr->bbalglbval;
bndgrafdat.domndist = orggrafptr->domndist;
bndgrafdat.domnwght[0] = orggrafptr->domnwght[0];
bndgrafdat.domnwght[1] = orggrafptr->domnwght[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->domndist + reduglbtab[1];
orggrafptr->commglbgainextn = reduglbtab[2];
orggrafptr->bbalglbval = (double) ((orggrafptr->compglbload0dlt < 0) ? (- orggrafptr->compglbload0dlt) : orggrafptr->compglbload0dlt) / (double) orggrafptr->compglbload0avg;
#ifdef SCOTCH_DEBUG_BDGRAPH2
if (bdgraphCheck (orggrafptr) != 0) {
errorPrint ("bdgraphBipartBd: internal error (2)");
return (1);
}
#endif /* SCOTCH_DEBUG_BDGRAPH2 */
bdgraphExit (&bndgrafdat);
return (0);
}
int checkCommandLineArguments(int argc, char **argv)
{
int i,j;
/* This works not that well - but is probably better than no check */
assertStreamPrint(NULL, !strcmp(FLAG_NAME[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_NAME");
assertStreamPrint(NULL, !strcmp(FLAG_DESC[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_DESC");
assertStreamPrint(NULL, !strcmp(FLAG_DETAILED_DESC[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_DETAILED_DESC");
for(i=0; i<FLAG_MAX; ++i)
{
omc_flag[i] = 0;
omc_flagValue[i] = NULL;
}
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 1, "used command line options");
for(i=1; i<argc; ++i)
debugStreamPrint(LOG_STDOUT, 0, "%s", argv[i]);
messageClose(LOG_STDOUT);
debugStreamPrint(LOG_STDOUT, 1, "interpreted command line options");
#endif
for(i=1; i<argc; ++i)
{
int found=0;
for(j=1; j<FLAG_MAX; ++j)
{
if((FLAG_TYPE[j] == FLAG_TYPE_FLAG) && flagSet(FLAG_NAME[j], 1, argv+i))
{
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s", FLAG_NAME[j]);
#endif
break;
} else if((FLAG_TYPE[j] == FLAG_TYPE_OPTION) && flagSet(FLAG_NAME[j], 1, argv+i) && (i+1 < argc)) {
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
omc_flagValue[j] = (char*)getFlagValue(FLAG_NAME[j], 1, argv+i);
i++;
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s %s", FLAG_NAME[j], omc_flagValue[j]);
#endif
break;
} else if((FLAG_TYPE[j] == FLAG_TYPE_OPTION) && optionSet(FLAG_NAME[j], 1, argv+i)) {
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
omc_flagValue[j] = (char*)getOption(FLAG_NAME[j], 1, argv+i);
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s=%s", FLAG_NAME[j], omc_flagValue[j]);
#endif
break;
}
}
if(!found)
{
#ifdef USE_DEBUG_OUTPUT
messageClose(LOG_STDOUT);
#endif
warningStreamPrint(LOG_STDOUT, 0, "invalid command line option: %s", argv[i]);
return 1;
}
}
#ifdef USE_DEBUG_OUTPUT
messageClose(LOG_STDOUT);
#endif
return 0;
}
int helpFlagSet(int argc, char** argv)
{
return flagSet("?", argc, argv) || flagSet("help", argc, argv);
}
