Rejigged algo to write out starMap every tier of numStars.

Author: highperformancecoder

models/starComplexity.cc

@@ -293,138 +293,137 @@ sycl::info::event_command_status eventStatus(Event ev)
 }
 #endif
 
-void StarComplexityGen::fillStarMap(unsigned maxStars)
+void StarComplexityGen::fillStarMap(unsigned numStars)
 {
   if (elemStars.empty()) return;
-  // insert the single star graph
-  starMap.emplace(elemStars[0],1);
-  counts.emplace(elemStars[0],1);
+  if (numStars==1)
+    {
+      // insert the single star graph
+      starMap.emplace(elemStars[0],1);
+      counts.emplace(elemStars[0],1);
+      return;
+    }
 
-  //unsigned numStars=maxStars;
-  for (unsigned numStars=2; numStars<=maxStars; ++numStars)
-  {
-    ecolab::DeviceType<BlockEvaluator> block(blockSize, numStars,elemStars);
-    Event resultSwapped, alreadySeenSwapped, starMapPopulated,backedResultsReset;
-    atomic<bool> populating=false;
-    atomic<unsigned> resultBufferConsumed=0;
-    const unsigned numOps=1<<(numStars-1);
-
-    bool blown=false;
-    auto populateStarMap=[&]() {
-      for (auto& j: block->getResults())
-        {
-          if (j.blown())
-            {
-              blown=true;
-              return;
-            }
-          for (auto k: j)
-            {
-              auto res=starMap.emplace(k, numStars);
-              if (res.first->second==numStars) // only count least star operations
-                counts[k]++;
-            }
-        }
-    };
+  ecolab::DeviceType<BlockEvaluator> block(blockSize, numStars,elemStars);
+  Event resultSwapped, alreadySeenSwapped, starMapPopulated,backedResultsReset;
+  atomic<bool> populating=false;
+  atomic<unsigned> resultBufferConsumed=0;
+  const unsigned numOps=1<<(numStars-1);
 
-    //int numLoops=3000;
-    do
+  bool blown=false;
+  auto populateStarMap=[&]() {
+    for (auto& j: block->getResults())
       {
-        auto start=time(nullptr);
+        if (j.blown())
+          {
+            blown=true;
+            return;
+          }
+        for (auto k: j)
+          {
+            auto res=starMap.emplace(k, numStars);
+            if (res.first->second==numStars) // only count least star operations
+              counts[k]++;
+          }
+      }
+  };
 
+  //int numLoops=3000;
+  do
+    {
+      auto start=time(nullptr);
+      
 #ifdef SYCL_LANGUAGE_VERSION
-        /* Using SYCL dependency graph structure, to run the compute
-           side simultaneously with accumulating results in the
-           starMap on the host. sycl::event is used to coordinate host
-           and device threads. */
-        vector<Event> compute;
-
-        auto consumeResults=[&](bool lastLoop) {
-          // retrieve results to host by swapping with backing buffers
-          resultSwapped=syclQ().single_task
-            (compute,[block=&*block](){
-              block->result.swap(block->backedResult);
-            });
-          backedResultsReset=syclQ().parallel_for
-            (blockSize,resultSwapped,[block=&*block](auto i){block->backedResult[i].reset();});
-                
-          // accumulate starMap results on separate host thread
-          starMapPopulated=syclQ().submit([&](auto& handler) {
-            handler.depends_on(resultSwapped);
-            handler.host_task([&]() {
-              resultBufferConsumed=0;
-              populateStarMap();
-//              if (!lastLoop)
-//                {
-//                  block->alreadySeenBacked.clear();
-//                  for (auto& k: starMap) block->alreadySeenBacked.push_back(k.first);
-//                  // push update already seen vector to device
-//                  alreadySeenSwapped=syclQ().single_task
-//                    (compute,
-//                     [=,block=&*block]{
-//                       block->alreadySeen.swap(block->alreadySeenBacked);
-//                     });
-//                }
-              populating=false;
-            });
+      /* Using SYCL dependency graph structure, to run the compute
+         side simultaneously with accumulating results in the
+         starMap on the host. sycl::event is used to coordinate host
+         and device threads. */
+      vector<Event> compute;
+
+      auto consumeResults=[&](bool lastLoop) {
+        // retrieve results to host by swapping with backing buffers
+        resultSwapped=syclQ().single_task
+          (compute,[block=&*block](){
+            block->result.swap(block->backedResult);
+          });
+        backedResultsReset=syclQ().parallel_for
+          (blockSize,resultSwapped,[block=&*block](auto i){block->backedResult[i].reset();});
+        
+        // accumulate starMap results on separate host thread
+        starMapPopulated=syclQ().submit([&](auto& handler) {
+          handler.depends_on(resultSwapped);
+          handler.host_task([&]() {
+            resultBufferConsumed=0;
+            populateStarMap();
+            //              if (!lastLoop)
+            //                {
+            //                  block->alreadySeenBacked.clear();
+            //                  for (auto& k: starMap) block->alreadySeenBacked.push_back(k.first);
+            //                  // push update already seen vector to device
+            //                  alreadySeenSwapped=syclQ().single_task
+            //                    (compute,
+            //                     [=,block=&*block]{
+            //                       block->alreadySeen.swap(block->alreadySeenBacked);
+            //                     });
+            //                }
+            populating=false;
           });
+        });
 
-          Event::wait({resultSwapped,backedResultsReset});
-          resultBufferConsumed=0;
-        };
+        Event::wait({resultSwapped,backedResultsReset});
+        resultBufferConsumed=0;
+      };
 
-        for (unsigned i=0; i<block->numGraphs; i+=blockSize)
-          {
-//            if (resultBufferConsumed+numOps>=OutputBuffer::maxQ)
-//              {
-//                consumeResults(i+blockSize>=block->numGraphs);
-//                cout<<"pausing..."<<endl;
-//                backedResultsReset.wait();
-////                while (resultBufferConsumed)
-////                  usleep(1000); // pause until results consumed
-//              }
-            
-            // compute a block of graphs
-            compute.push_back
-              (syclQ().parallel_for(blockSize, {resultSwapped, alreadySeenSwapped},
-                                    [=,block=&*block](auto j){block->eval(i,j);}));
-            resultBufferConsumed+=numOps;
-
-            if (eventStatus(starMapPopulated)==sycl::info::event_command_status::complete)
-              // throttle consuming thread
-              consumeResults(i+blockSize>=block->numGraphs);
-          }
-        // wait until all compute threads finish before bumping pos
-        Event::wait(compute);
+      for (unsigned i=0; i<block->numGraphs; i+=blockSize)
+        {
+          //            if (resultBufferConsumed+numOps>=OutputBuffer::maxQ)
+          //              {
+          //                consumeResults(i+blockSize>=block->numGraphs);
+          //                cout<<"pausing..."<<endl;
+          //                backedResultsReset.wait();
+          ////                while (resultBufferConsumed)
+          ////                  usleep(1000); // pause until results consumed
+          //              }
+          
+          // compute a block of graphs
+          compute.push_back
+            (syclQ().parallel_for(blockSize, {resultSwapped, alreadySeenSwapped},
+                                  [=,block=&*block](auto j){block->eval(i,j);}));
+          resultBufferConsumed+=numOps;
+          
+          if (eventStatus(starMapPopulated)==sycl::info::event_command_status::complete)
+            // throttle consuming thread
+            consumeResults(i+blockSize>=block->numGraphs);
+        }
+      // wait until all compute threads finish before bumping pos
+      Event::wait(compute);
 #else
-        for (unsigned i=0; i<block->numGraphs; i+=block->size())
-          for (unsigned j=0; j<block->size(); ++j)
-            block->eval(i,j);
-        populateStarMap();
+      for (unsigned i=0; i<block->numGraphs; i+=block->size())
+        for (unsigned j=0; j<block->size(); ++j)
+          block->eval(i,j);
+      populateStarMap();
 #endif
-        if (blown)
-          {
-            cout<<"buffer blown, throwing"<<endl;
+      if (blown)
+        {
+          cout<<"buffer blown, throwing"<<endl;
 #ifdef SYCL_LANGUAGE_VERSION
-            syclQ().wait(); // flush queue before destructors called
+          syclQ().wait(); // flush queue before destructors called
 #endif
-            throw runtime_error("Output buffer blown");
-          }
+          throw runtime_error("Output buffer blown");
+        }
 
-        //cout<<"loops rem="<<numLoops<<" resultBufferConsumed:"<<unsigned(resultBufferConsumed)<<" "<<(time(nullptr)-start)<<"secs\n";
-      } while (block->pos.next() /*&& --numLoops>0*/);
+      //cout<<"loops rem="<<numLoops<<" resultBufferConsumed:"<<unsigned(resultBufferConsumed)<<" "<<(time(nullptr)-start)<<"secs\n";
+    } while (block->pos.next() /*&& --numLoops>0*/);
 #ifdef SYCL_LANGUAGE_VERSION
-    auto start=time(nullptr);
-    resultSwapped=syclQ().single_task
-      ([block=&*block](){
-        block->result.swap(block->backedResult);
-      });
-    populateStarMap();
-    syclQ().wait_and_throw(); // flush queue before destructors called
-    cout<<"numStars done:"<<numStars<<endl;
-    //cout<<"Final wait:"<<(time(nullptr)-start)<<"secs\n";
+  auto start=time(nullptr);
+  resultSwapped=syclQ().single_task
+    ([block=&*block](){
+      block->result.swap(block->backedResult);
+    });
+  populateStarMap();
+  syclQ().wait_and_throw(); // flush queue before destructors called
 #endif
-  }
+
 }
 
 NautyRep toNautyRep(linkRep g, unsigned nodes)

models/starComplexity.h

@@ -128,7 +128,7 @@ struct StarComplexityGen
   ElemStars elemStars;
   void generateElementaryStars(unsigned nodes);
   // fills starMap with graphs of \a numStars
-  void fillStarMap(unsigned maxStars);
+  void fillStarMap(unsigned numStars);
   void canonicaliseStarMap();
   /// return complement canonical graph
   linkRep complement(linkRep) const;

models/starComplexity.py

@@ -13,20 +13,24 @@
 print('maxStars=',maxStars)
 maxStars=8
 
-starC.blockSize(256)
-#starC.blockSize(4096)
+#starC.blockSize(256)
+starC.blockSize(4096)
+#starC.blockSize(8192)
 #starC.blockSize(17920)
 #starC.blockSize(40320)
 
 starC.generateElementaryStars(nodes)
-starC.fillStarMap(maxStars)
-starC.canonicaliseStarMap()
-
-print('g','links','*','C','C*','omega(g)','omega(g\')',sep=',')
-for i in starC.starMap.keys():
-    c=starC.complexity(i)
-    links=0
-    for j in i:
-        links+=bin(j).count('1')
-    print(links,starC.symmStar(i),c.complexity(),c.starComplexity(),starC.counts[i],starC.counts[starC.complement(i)()],sep=',')
-
+for numStars in range(2,maxStars+1):
+    starC.fillStarMap(numStars)
+    print('completed',numStars)
+    starC.canonicaliseStarMap()
+    with open(f'{nodes}-{maxStars}.csv','w') as out:
+        print('id,links','*','C','C*','omega(g)','omega(g\')',sep=',',file=out)
+        id=0
+        for i in starC.starMap.keys():
+            c=starC.complexity(i)
+            links=0
+            for j in i:
+                links+=bin(j).count('1')
+            print(id,links,starC.symmStar(i)-1,c.complexity(),c.starComplexity(),starC.counts[i],starC.counts[starC.complement(i)()],sep=',',file=out)
+            id+=1