DESunordered.h

Go to the documentation of this file.

#ifndef _DES_UNORDERED_H_
#define _DES_UNORDERED_H_

#include "Galois/Galois.h"
#include "Galois/Runtime/WorkList.h"
#include "Galois/util/Accumulator.h"

#include "DESabstractMain.h"


static const bool DEBUG = false;


class DESunordered: public DESabstractMain {
  typedef Galois::GAccumulator<int> PerCPUcounter;
  typedef Galois::GReduceMax<size_t> ReduceMax;

  struct process {
    Graph& graph;
    std::vector<unsigned int>& onWlFlags;
    PerCPUcounter& numEvents;
    PerCPUcounter& numIter;
    ReduceMax& maxPending;

    
    process (
    Graph& graph,
    std::vector<unsigned int>& onWlFlags,
    PerCPUcounter& numEvents,
    PerCPUcounter& numIter,
    ReduceMax& maxPending)
      : graph (graph), onWlFlags (onWlFlags), numEvents (numEvents), numIter (numIter), maxPending (maxPending) {}



    template <typename ContextTy>
    void operator () (GNode& activeNode, ContextTy& lwl) {
        SimObject* srcObj = graph.getData (activeNode, Galois::CHECK_CONFLICT);

        // acquire locks on neighborhood: one shot
        for (Graph::neighbor_iterator i = graph.neighbor_begin (activeNode, Galois::CHECK_CONFLICT)
            , ei = graph.neighbor_end (activeNode, Galois::CHECK_CONFLICT); i != ei; ++i) {
          // const GNode& dst = *i;
          // SimObject* dstObj = graph.getData (dst, Galois::CHECK_CONFLICT);
        }



        // should be past the fail-safe point by now

        if (DEBUG) {
          // DEBUG
          printf ("%d processing : %s\n", ThreadPool::getMyID (), srcObj->toString ().c_str ());
        }

        maxPending.update (srcObj->numPendingEvents ());

        int proc = srcObj->simulate(graph, activeNode); // number of events processed
        numEvents.get () += proc;

        for (Graph::neighbor_iterator i = graph.neighbor_begin (activeNode, Galois::NONE)
            , ei = graph.neighbor_end (activeNode, Galois::NONE); i != ei; ++i) {
          const GNode& dst = *i;

          SimObject* dstObj = graph.getData (dst, Galois::NONE);

          dstObj->updateActive ();

          if (dstObj->isActive ()) {

            if (onWlFlags[dstObj->getId ()] == 0) {
              if (DEBUG) {
                // DEBUG
                printf ("%d Added %d neighbor: %s\n" , ThreadPool::getMyID (), onWlFlags[dstObj->getId ()], dstObj->toString ().c_str ());
              }
              onWlFlags[dstObj->getId ()] = 1;
              lwl.push (dst);

            }

          }
        }

        srcObj->updateActive();

        if (srcObj->isActive()) {
          lwl.push (activeNode);
          
          if (DEBUG) {
            //DEBUG
            printf ("%d Added %d self: %s\n" , ThreadPool::getMyID (), onWlFlags[srcObj->getId ()], srcObj->toString ().c_str ());
          }

        }
        else {
          onWlFlags[srcObj->getId ()] = 0;
          if (DEBUG) {
            //DEBUG
            printf ("%d not adding %d self: %s\n" , ThreadPool::getMyID (), onWlFlags[srcObj->getId ()], srcObj->toString ().c_str ());
          }
        }

        ++(numIter.get ());

    }
  };

  virtual void runLoop (const SimInit& simInit) {
    const std::vector<GNode>& initialActive = simInit.getInputNodes();


    std::vector<unsigned int> onWlFlags (simInit.getNumNodes (), 0);
    // set onWlFlags for input objects
    for (std::vector<GNode>::const_iterator i = simInit.getInputNodes ().begin (), ei = simInit.getInputNodes ().end ();
        i != ei; ++i) {
      SimObject* srcObj = graph.getData (*i, Galois::NONE);
      onWlFlags[srcObj->getId ()] = 1;
    }



    PerCPUcounter numEvents;
    PerCPUcounter numIter;
    ReduceMax maxPending;

    process p(graph, onWlFlags, numEvents, numIter, maxPending);

    Galois::for_each < GaloisRuntime::WorkList::FIFO<GNode> > (initialActive.begin (), initialActive.end (), p);

    std::cout << "Number of events processed = " << numEvents.get () << std::endl;
    std::cout << "Number of iterations performed = " << numIter.get () << std::endl;
    std::cout << "Maximum size of pending events = " << maxPending.get () << std::endl;
  }

  virtual bool isSerial () const { return false; }
};


#endif // _DES_UNORDERED_H_

---