Charm++ parallel programming system

[SAGAR SHEDGE <sagar.shedge92 AT gmail.com>]

Respected Sir/Mam,

          I am trying to run code from charm++/examples/commlib/multicast. But it gives me following error.

Also I am sending code.

So please give me solution.

Error is :-
 gm.C:20:97: warning: deprecated conversion from string constant to ‘char*’
pgm.C:20:97: warning: deprecated conversion from string constant to ‘char*’
pgm.C:20:97: warning: deprecated conversion from string constant to ‘char*’
pgm.C: In constructor ‘Main::Main(CkArgMsg*)’:
pgm.C:78:61: error: no matching function for call to ‘DirectMulticastStrategy::DirectMulticastStrategy(CProxy_Destination&)’
/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include/DirectMulticastStrategy.h:50:5: note: candidates are: DirectMulticastStrategy::DirectMulticastStrategy()
/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include/DirectMulticastStrategy.h:47:5: note:                 DirectMulticastStrategy::DirectMulticastStrategy(CkMigrateMessage*)
/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include/DirectMulticastStrategy.h:23:57: note:                 DirectMulticastStrategy::DirectMulticastStrategy(const DirectMulticastStrategy&)
pgm.C:79:41: error: cannot convert ‘CharmStrategy*’ to ‘Strategy*’ for argument ‘1’ to ‘ComlibInstanceHandle ComlibRegister(Strategy*)’
pgm.C:81:44: error: no matching function for call to ‘RingMulticastStrategy::RingMulticastStrategy(CProxy_Destination&)’
/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include/RingMulticastStrategy.h:31:5: note: candidates are: RingMulticastStrategy::RingMulticastStrategy(CkMigrateMessage*)
/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include/RingMulticastStrategy.h:30:5: note:                 RingMulticastStrategy::RingMulticastStrategy()
/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include/RingMulticastStrategy.h:18:55: note:                 RingMulticastStrategy::RingMulticastStrategy(const RingMulticastStrategy&)
pgm.C:82:39: error: cannot convert ‘CharmStrategy*’ to ‘Strategy*’ for argument ‘1’ to ‘ComlibInstanceHandle ComlibRegister(Strategy*)’
pgm.C:84:18: error: expected type-specifier before ‘MultiRingMulticast’
pgm.C:84:18: error: cannot convert ‘int*’ to ‘CharmStrategy*’ in assignment
pgm.C:84:18: error: expected ‘;’ before ‘MultiRingMulticast’
pgm.C:85:44: error: cannot convert ‘CharmStrategy*’ to ‘Strategy*’ for argument ‘1’ to ‘ComlibInstanceHandle ComlibRegister(Strategy*)’
pgm.C: In constructor ‘Source::Source(int, int*)’:
pgm.C:112:53: error: invalid conversion from ‘ComlibInstanceHandle*’ to ‘ComlibInstanceHandle’
pgm.C:112:53: error:   initializing argument 1 of ‘void ComlibAssociateProxy(ComlibInstanceHandle, CProxy&)’
pgm.C:115:49: error: invalid conversion from ‘ComlibInstanceHandle*’ to ‘ComlibInstanceHandle’
pgm.C:115:49: error:   initializing argument 1 of ‘void ComlibAssociateProxy(ComlibInstanceHandle, CProxy&)’
pgm.C:118:59: error: invalid conversion from ‘ComlibInstanceHandle*’ to ‘ComlibInstanceHandle’
pgm.C:118:59: error:   initializing argument 1 of ‘void ComlibAssociateProxy(ComlibInstanceHandle, CProxy&)’
Fatal Error by charmc in directory /home/sagee/charm-6.2/net-linux-local-tcp-gcc/examples/charm++/commlib/multicast
   Command g++ -fPIC -Wno-deprecated -I/home/sagee/charm-6.2/net-linux-local-tcp-gcc/bin/../include -D__CHARMC__=1 -c pgm.C -o pgm.o returned error code 1
charmc exiting...
make: *** [pgm.o] Error 1



--

Sagar Dilip Shedge,
C-DAC R&D,
Pune.

 

With Regards.

 

#include <stdlib.h>
#include <alloca.h>
#include <time.h>
#include <string.h>

#include "pgm.h"

/* Proxies to allow charm structures to talk to each other */
CProxy_Main mainProxy;
CProxy_Source src;
CProxy_Destination dest;

/* Declaration of the three readonly variables used to hold the instances of
   multicast strategies. In this way the association with the ProxySections can
   be performed on any processor. */
ComlibInstanceHandle strat_direct;
ComlibInstanceHandle strat_ring;
ComlibInstanceHandle strat_multiring;

char *strategyName[3] = {"DirectMulticastStrategy", "RingMulticastStrategy", "MultiRingStrategy"};

Main::Main(CkArgMsg *m) {
  count = 0;

  // some hardcoded values
  nsrc = 1000;
  ndest = 1000;
  int mcastFactor = 50;
  iteration = 0;

  mainProxy = thishandle;

  // create the random mapping of sender-receiver
  char **matrix = (char **) alloca(nsrc * sizeof(char*));
  matrix[0] = (char *) malloc(nsrc * ndest * sizeof(char));
  memset(matrix[0], 0, nsrc * ndest * sizeof(char));
  for (int i=1; i<nsrc; ++i) matrix[i] = matrix[i-1] + ndest;

  srand48(time(NULL));
  for (int i=0; i<nsrc; ++i) {
    for (int j=0; j<mcastFactor; ++j) {
      int k = int(drand48() * ndest);
      matrix[i][k] = 1;
    }
  }

  // create the source and destination proxies
  src = CProxy_Source::ckNew();
  int *indices = (int *) alloca (mcastFactor * sizeof(int));
  for (int i=0; i<nsrc; ++i) {
    int idx = 0;
    //CkPrintf("%d: sending to ",i);
    for (int j=0; j<ndest; ++j) {
      if (matrix[i][j] > 0) {
	indices[idx++] = j;
	//CkPrintf("%d ",j);
      }
    }
    //CkPrintf("\n");
    src[i].insert(idx, indices);
  }
  src.doneInserting();

  dest = CProxy_Destination::ckNew();
  int empty = 0;
  for (int i=0; i<ndest; ++i) {
    int cnt = 0;
    for (int j=0; j<nsrc; ++j)
      if (matrix[j][i] > 0) cnt++;
    //CkPrintf("dest %d: receiving from %d\n",i,cnt);
    dest[i].insert(cnt);
    if (cnt == 0) empty++;
  }
  dest.doneInserting();
  ndest -= empty;

  // create the strategies and register them to commlib
  CharmStrategy *strategy = new DirectMulticastStrategy(dest);
  strat_direct = ComlibRegister(strategy);

  strategy = new RingMulticastStrategy(dest);
  strat_ring = ComlibRegister(strategy);

  strategy = new MultiRingMulticast(dest);
  strat_multiring = ComlibRegister(strategy);

  CkPrintf("Starting new iteration\n");
  src.start(++iteration);
}

/* invoked when the multicast has finished, will start next iteration, or end the program */
void Main::done() {
  if (++count == ndest) {
    CkPrintf("Iteration %d (%s) finished\n", iteration,strategyName[iteration-1]);
    count = 0;
    if (iteration == 3) CkExit();
    else {
      CkPrintf("Starting new iteration\n");
      src.start(++iteration);
    }
  }
}


Source::Source(int n, int *indices) {
  CkArrayIndexMax *elems = (CkArrayIndexMax*) alloca(n * sizeof(CkArrayIndexMax));
  for (int i=0; i<n; ++i) elems[i] = CkArrayIndex1D(indices[i]);

  /* Create the ProxySections and associate them with the three different
     instances of commlib multicasts. */
  direct_section = CProxySection_Destination::ckNew(dest, elems, n);
  ComlibAssociateProxy(&strat_direct, direct_section);

  ring_section = CProxySection_Destination::ckNew(dest, elems, n);
  ComlibAssociateProxy(&strat_ring, ring_section);

  multiring_section = CProxySection_Destination::ckNew(dest, elems, n);
  ComlibAssociateProxy(&strat_multiring, multiring_section);
}

void Source::start(int i) {
  MyMulticastMessage *msg = new (1000) MyMulticastMessage();
  //CkPrintf("Source %d: starting multicast %d\n",thisIndex,i);
  // Perform a multicast, using one of the strategies through the associated proxies
  switch (i) {
  case 1:
    direct_section.receive(msg);
    break;
  case 2:
    ring_section.receive(msg);
    break;
  case 3:
    multiring_section.receive(msg);
    break;
  default:
    CkAbort("Invalid iteration");
  }
}


Destination::Destination(int senders) {
  nsrc = senders;
  waiting = senders;
  //CkPrintf("dest %d: waiting for %d messages\n",thisIndex,senders);
}

void Destination::receive(MyMulticastMessage *m) {
  delete m;
  //CkPrintf("Destination %d: received, remaining %d\n",thisIndex,waiting);
  if (--waiting == 0) {
    // all messages received, send message to main
    //CkPrintf("Destination %d: received all\n",thisIndex);
    waiting = nsrc;
    mainProxy.done();
  }
}

#include "pgm.def.h"

Attachment: pgm.ci
Description: Binary data

#include "comlib.h"

#include "pgm.decl.h"

extern CProxy_Main mainProxy;
extern CProxy_Source src;
extern CProxy_Destination dest;

extern ComlibInstanceHandle strat_direct;
extern ComlibInstanceHandle strat_ring;
extern ComlibInstanceHandle strat_multiring;

class MyMulticastMessage : public CkMcastBaseMsg, public CMessage_MyMulticastMessage {
 public:
  char *data;
};

class Main : public CBase_Main {
 private:
  int nsrc, ndest;
  int count;
  int iteration;
 public:
  Main(CkArgMsg *m);
  void done();
};

class Source : public CBase_Source {
 private:
  /* local variables used to keep the sections for the multicast.
     each of them will be associated with a specific strategy */
  CProxySection_Destination direct_section;
  CProxySection_Destination ring_section;
  CProxySection_Destination multiring_section;
 public:
  Source(int n, int *list);
  Source(CkMigrateMessage *m) {}
  void start(int i);
};

class Destination : public CBase_Destination {
 private:
  int waiting;
  int nsrc;
 public:
  Destination(int senders);
  Destination(CkMigrateMessage *m) {}
  void receive(MyMulticastMessage *m);
};