#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <ctype.h>
#include <string.h>
#include "timers.c"
#include "pvm3.h"

#define HostNode 704
#define NodeHost 1943
#define NodeName "queen-node"
#define HostName "queen-host"

long int Nunique = 0,
         Ntotal  = 0;

int Nnodes, tids[32];;

float *Calc, Lapsed = 0;

void StartNodes()
{
   int MyNum, Idx, Instance, Status;
   int Bytes, MsgType, NodeNum;
   int bufid;

   MyNum = pvm_mytid();
   Idx = pvm_spawn (NodeName, NULL, 0, "", Nnodes, tids);
   if (Idx < Nnodes)
   {
      puts ("\nFailed to initiate all instances.  Aborting . . .");
      pvm_exit();
      exit (1);
   }
 
   for (Idx = 0; Idx < Nnodes; Idx++)
   {
      bufid = pvm_recv (tids[Idx], NodeHost-1);
      pvm_upkint (&Instance, 1, 1);
      pvm_bufinfo (bufid, &Bytes, &MsgType, &NodeNum);
/*    For debugging:  should have tids[Idx] == Instance == NodeNum.  */
   }
}

void Launch (Board, Size, Node)
int Board[], Size, Node;
{
   pvm_initsend (PvmDataRaw);
   pvm_pkint (&Size, 1, 1);
   pvm_pkint (Board, Size, 1);
   pvm_send (tids[Node], HostNode);
}

void Scuttle ()
{
   int Zero = 0;

   pvm_initsend(PvmDataRaw);
   pvm_pkint (&Zero, 1, 1);
   pvm_mcast (tids, Nnodes, HostNode);
   pvm_exit();
}

int Finished()
{
   int   Node;
   long  Count;
   int   bufid;
   int   Bytes, MsgType;
   float JobTime;

   bufid = pvm_recv (-1, NodeHost);
   pvm_bufinfo (bufid, &Bytes, &MsgType, &Node);
   Node = LinSearch (Node, tids, Nnodes);
   pvm_upklong (&Count, 1, 1);
   Nunique += Count;
   pvm_upklong (&Count, 1, 1);
   Ntotal  += Count;
   pvm_upkfloat (&JobTime, 1, 1);
   Calc[Node] += JobTime;
   return Node;
}

int LinSearch (int Item, int X[], int N)
{
   int Idx;

   for (Idx = N-1; Idx >= 0; Idx--)
      if (Item == X[Idx]) break;
   return Idx;
}

void FarmOut (Board, Size)
int Board[], Size;
{
   int
   Active = 0,    /* Number of node processes active        */
   NextUp = 0,    /* Column position for row-0 queen        */
   Node = 0,      /* Node process receiving a configuration */
   Lim = (Size+1)/2; /* We only need do the left half       */


   while (1)
   {
      int Temp;

      while ( NextUp < Lim && Active < Nnodes )
      {
         if ( NextUp > 0)
         {
            Temp = Board[0];
            Board[0] = Board[NextUp];
            Board[NextUp] = Temp;
         }
      /*    Launch sends the problem to the indicated Node     */
         Launch (Board, Size, Node);
         Node++ ; NextUp++ ; Active++ ;
      }
      if ( Active == 0 ) break;
   /* Finished() processes one node's returned information     */
      Node = Finished();  /* So Node is ready for Launch    */
      Active--; /* if NextUp < Lim, while loop launches one */
   }
   Scuttle();
}

main(argc, argv)
int   argc;
char *argv[];
{
   int  *Board, *Trial, Idx, Lim, Size;
   FILE *fptr;
   float Clock, CPUscr, ClockScr;
   float CPUtot;

   if (argc < 2)
   {
      fputs ("Size:  ", stdout);
      scanf ("%d", &Size);
   }
   else
   {
      Size = atoi(argv[1]);
   }
   if (argc < 3)
   {
      fputs ("Number of node processes:  ", stdout);
      scanf ("%d", &Nnodes);
   }
   else
   {
      Nnodes = atoi(argv[2]);
   }
   if (Nnodes < 1)
   {
      puts ("Need at least 1; setting No. nodes to 1");
      Nnodes = 1;
   }
   StartNodes();

   Board = (int *) calloc (Size, sizeof *Board);
   Calc  = (float *) calloc (Nnodes, sizeof *Calc);
/* Initial permutation generated. */
   for (Idx = 0; Idx < Size; Idx++)
      Board[Idx] = Idx;

   cputime(&CPUscr);                 /* Zero the counter */
   ClockTime(&ClockScr);
   FarmOut (Board, Size);
   Lapsed = CPUtot = cputime(&CPUscr);
   Clock = ClockTime(&ClockScr);

   for (Idx = 0; Idx < Nnodes; Idx++)
      CPUtot += Calc[Idx];

   printf ("%3d ==> %10ld  %10ld  %10.4f  %10.4f\n",
           Size, Nunique, Ntotal, CPUtot, Clock);

   fptr = fopen("Nqueens.out", "a");
   fprintf (fptr, "%3d ==> %10ld  %10ld  %10.4f  %10.4f",
            Size, Nunique, Ntotal, CPUtot, Clock);

   fprintf (fptr, " %8.4f", Lapsed);
   for (Idx = 0; Idx < Nnodes; Idx++)
      fprintf (fptr, " %8.4f", Calc[Idx]);
   
   fputc ('\n', fptr);
   fclose (fptr);

   return 0;
}