Best PFT ever!

[Tuberski]

Operation Desert Storm was largely his plan as well.

ACK!

[SlowwHand]

The Marines are easily the most forward-thinking and effective service branch in the US military. They get the job done, while the Air Force doesn't even pretend that it wants to do important jobs (like CAS). The Air Force is too busy golfing to actually help win wars and save American lives.

You're such a fool.

[Hauldren Collider]

I dunno, I think the air force has some pretty good flying bus drivers. The A-10 is also pretty cool.

[SlowwHand]

BTW, Tupac, you never said what branch you were in. Let me ask you again, since I know you're kind of addled.

[Hauldren Collider]

He's correct in that the air force is a little bit obsessed with its "sexy" jobs like fighter pilot. The fact of the matter is we need cargo planes, bombers, and close air support far more than we need air-to-air superiority fighters. We also need to start moving towards UAVs and the air force has resisted that, which is why the CIA now operates most of our predators.

The Air Force is slow to change, despite being probably the most technologically sophisticated branch (the Navy may beat it there, hard to say).

[loinburger]

Best DFT ever!

typedef struct {
     solver super;
     int preserve_input;
} S;

typedef struct {
     plan_mpi_dft super;

     plan *cld1, *cld2;
     INT roff, ioff;
     int preserve_input;
} P;

static void apply(const plan *ego_, R *I, R *O)
{
     const P *ego = (const P *) ego_;
     plan_dft *cld1;
     plan_rdft *cld2;
     INT roff = ego->roff, ioff = ego->ioff;
     
     /* DFT local dimensions */
     cld1 = (plan_dft *) ego->cld1;
     if (ego->preserve_input) {
	  cld1->apply(ego->cld1, I+roff, I+ioff, O+roff, O+ioff);
	  I = O;
     }
     else
	  cld1->apply(ego->cld1, I+roff, I+ioff, I+roff, I+ioff);

     /* DFT non-local dimension (via dft-rank1-bigvec, usually): */
     cld2 = (plan_rdft *) ego->cld2;
     cld2->apply(ego->cld2, I, O);
}

static int applicable(const S *ego, const problem *p_,
		      const planner *plnr)
{
     const problem_mpi_dft *p = (const problem_mpi_dft *) p_;
     return (1
	     && p->sz->rnk > 1
	     && p->flags == 0 /* TRANSPOSED/SCRAMBLED_IN/OUT not supported */
	     && (!ego->preserve_input || (!NO_DESTROY_INPUTP(plnr)
					  && p->I != p->O))
	     && XM(is_local_after)(1, p->sz, IB)
	     && XM(is_local_after)(1, p->sz, OB)
	     && (!NO_SLOWP(plnr) /* slow if dft-serial is applicable */
		 || !XM(dft_serial_applicable)(p))
	  );
}

static void awake(plan *ego_, enum wakefulness wakefulness)
{
     P *ego = (P *) ego_;
     X(plan_awake)(ego->cld1, wakefulness);
     X(plan_awake)(ego->cld2, wakefulness);
}

static void destroy(plan *ego_)
{
     P *ego = (P *) ego_;
     X(plan_destroy_internal)(ego->cld2);
     X(plan_destroy_internal)(ego->cld1);
}

static void print(const plan *ego_, printer *p)
{
     const P *ego = (const P *) ego_;
     p->print(p, "(mpi-dft-rank-geq2%s%(%p%)%(%p%))", 
	      ego->preserve_input==2 ?"/p":"", ego->cld1, ego->cld2);
}

static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr)
{
     const S *ego = (const S *) ego_;
     const problem_mpi_dft *p;
     P *pln;
     plan *cld1 = 0, *cld2 = 0;
     R *ri, *ii, *ro, *io, *I, *O;
     tensor *sz;
     dtensor *sz2;
     int i, my_pe, n_pes;
     INT nrest;
     static const plan_adt padt = {
          XM(dft_solve), awake, print, destroy
     };

     UNUSED(ego);

     if (!applicable(ego, p_, plnr))
          return (plan *) 0;

     p = (const problem_mpi_dft *) p_;

     X(extract_reim)(p->sign, I = p->I, &ri, &ii);
     X(extract_reim)(p->sign, O = p->O, &ro, &io);
     if (ego->preserve_input || NO_DESTROY_INPUTP(plnr)) 
	  I = O; 
     else { 
	  ro = ri;
	  io = ii;
     }
     MPI_Comm_rank(p->comm, &my_pe);
     MPI_Comm_size(p->comm, &n_pes);

     sz = X(mktensor)(p->sz->rnk - 1); /* tensor of last rnk-1 dimensions */
     i = p->sz->rnk - 2; A(i >= 0);
     sz->dims[i].n = p->sz->dims[i+1].n;
     sz->dims[i].is = sz->dims[i].os = 2 * p->vn;
     for (--i; i >= 0; --i) {
	  sz->dims[i].n = p->sz->dims[i+1].n;
	  sz->dims[i].is = sz->dims[i].os = sz->dims[i+1].n * sz->dims[i+1].is;
     }
     nrest = X(tensor_sz)(sz);
     {
          INT is = sz->dims[0].n * sz->dims[0].is;
          INT b = XM(block)(p->sz->dims[0].n, p->sz->dims[0].b[IB], my_pe);
	  cld1 = X(mkplan_d)(plnr,
                             X(mkproblem_dft_d)(sz,
                                                X(mktensor_2d)(b, is, is,
                                                               p->vn, 2, 2),
                                                ri, ii, ro, io));
	  if (XM(any_true)(!cld1, p->comm)) goto nada;
     }

     sz2 = XM(mkdtensor)(1); /* tensor for first (distributed) dimension */
     sz2->dims[0] = p->sz->dims[0];
     cld2 = X(mkplan_d)(plnr, XM(mkproblem_dft_d)(sz2, nrest * p->vn,
						  I, O, p->comm, p->sign, 
						  RANK1_BIGVEC_ONLY));
     if (XM(any_true)(!cld2, p->comm)) goto nada;

     pln = MKPLAN_MPI_DFT(P, &padt, apply);
     pln->cld1 = cld1;
     pln->cld2 = cld2;
     pln->preserve_input = ego->preserve_input ? 2 : NO_DESTROY_INPUTP(plnr);
     pln->roff = ri - p->I;
     pln->ioff = ii - p->I;

     X(ops_add)(&cld1->ops, &cld2->ops, &pln->super.super.ops);

     return &(pln->super.super);

 nada:
     X(plan_destroy_internal)(cld2);
     X(plan_destroy_internal)(cld1);
     return (plan *) 0;
}

static solver *mksolver(int preserve_input)
{
     static const solver_adt sadt = { PROBLEM_MPI_DFT, mkplan, 0 };
     S *slv = MKSOLVER(S, &sadt);
     slv->preserve_input = preserve_input;
     return &(slv->super);
}

void XM(dft_rank_geq2_register)(planner *p)
{
     int preserve_input;
     for (preserve_input = 0; preserve_input <= 1; ++preserve_input)
	  REGISTER_SOLVER(p, mksolver(preserve_input));
}

[Hauldren Collider]

Is that a parallelized Fourier transform? I'm just guessing from the MPI calls and wiki says DFT can stand for discrete fourier transform.

[loinburger]

Yeah, copy-pasted from FFTW

[Tupac Shakur]

I dunno, I think the air force has some pretty good flying bus drivers. The A-10 is also pretty cool.

The A-10 is awesome, but the Air Force has always hated it and only allowed it to be built in the first place because the Army was going to steal the CAS mission and the funding that goes with it.

BTW, the A-10 was the brainchild of Pierre Sprey, who you **** on in a thread about the F-35.

[Ben Kenobi]

If he had enough mental ability he'd go in the Air Force. I guess Marines might be my distant second choice.

Right - no bias there.

[SlowwHand]

No bias at all. The simple fact is that the Air Force has more stringent requirements for mental ability than any other branch of the service. If all you can be is a body, the Army takes almost anyone. Now, if your point is that I'm proud that the Air Force took me, you'll get no argument from me.

[Ben Kenobi]

They took you and they certainly won't take me, so I think that says everything about their standards. Air Force.

[SlowwHand]

A little different, Sean. You're Air Force capable mentally. Your hearing won't pass muster. If you ever want to serve, it will be in an effort outside the armed service, and that's fine. Lot of different ways to give back. I know that you know that. Boann has always called me "Old Soul". I think there's some old soul about you, too.

[Ben Kenobi]

A little different, Sean. You're Air Force capable mentally. Your hearing won't pass muster. If you ever want to serve, it will be in an effort outside the armed service, and that's fine. Lot of different ways to give back. I know that you know that. Boann has always called me "Old Soul". I think there's some old soul about you, too.

Aww, thanks.

I'm just happy to be here. Everyday in America is a good day.

Yeah, I share that feeling myself. Both you and boann are such nice people but very different from most folks. Good different not bad different.

[-Jrabbit]

Group hug! Kumbaya!