remove prints

Author: mneedham

algo/src/main/java/org/neo4j/graphalgo/impl/pagerank/BaseComputeStep.java

@@ -48,7 +48,6 @@ public abstract class BaseComputeStep implements ComputeStep {
     final int startNode;
     final int endNode;
     double l2Norm;
-    int iteration;
 
     BaseComputeStep(
             double dampingFactor,
@@ -73,8 +72,6 @@ public void setStarts(int starts[], int[] lengths) {
 
     @Override
     public void run() {
-        String name = String.format("[%s,startNode:%d,partitionSize:%d,iteration:%d,run] - run with current state: %s", this.getClass().getSimpleName(), this.startNode, this.partitionSize,this.iteration, state);
-        System.out.println(name);
         if (state == S_CALC) {
             singleIteration();
             state = S_SYNC;
@@ -126,9 +123,7 @@ private void initialize() {
 
     @Override
     public void prepareNormalizeDeltas(double l2Norm, int iteration) {
-//        System.out.println("l2Norm = " + l2Norm + ", iteration = " + iteration);
         this.l2Norm = l2Norm;
-        this.iteration = iteration;
     }
 
     public void prepareNextIteration(int[][] prevScores) {

algo/src/main/java/org/neo4j/graphalgo/impl/pagerank/EigenvectorCentralityComputeStep.java

@@ -80,8 +80,6 @@ protected double initialValue() {
 
     @Override
     void synchronizeScores(int[] allScores) {
-        double[] before = deltas.clone();
-
         double[] pageRank = this.pageRank;
 
         int length = allScores.length;
@@ -94,25 +92,12 @@ void synchronizeScores(int[] allScores) {
             allScores[i] = 0;
         }
 
-        String name = String.format("[%s,%d,%d, %d, synchronizeScores]", this.getClass().getSimpleName(), this.startNode, this.partitionSize, this.iteration);
-        System.out.println(name + "\nbefore: " + Arrays.toString(before) + "\nafter: " + Arrays.toString(deltas));
     }
 
     @Override
     void normalizeDeltas() {
-//        double[] before = deltas.clone();
         for (int i = 0; i < deltas.length; i++) {
             deltas[i] = deltas[i] / l2Norm;
         }
-//        String name = String.format("[%s,%d,%d, %d]", this.getClass().getSimpleName(), this.startNode, this.partitionSize, this.iteration);
-//        System.out.println(name + "\nnorm: " + l2Norm + "\nbefore: " + Arrays.toString(before) + "\nafter: " + Arrays.toString(deltas));
-    }
-
-    @Override
-    public String toString() {
-        return "EigenvectorCentralityComputeStep{" +
-                "partitionSize=" + partitionSize +
-                ", startNode=" + startNode +
-                '}';
     }
 }

algo/src/main/java/org/neo4j/graphalgo/impl/pagerank/PageRank.java

@@ -351,49 +351,38 @@ CentralityResult getPageRank() {
 
         private void run(int iterations) {
             // initialize data structures
-            System.out.println("[pre iterations] init data structures");
             ParallelUtil.runWithConcurrency(concurrency, steps, pool);
             for (int iteration = 0; iteration < iterations && running(); iteration++) {
-                System.out.println("-------");
-                System.out.println("[iteration started] iteration:" + iteration);
                 // calculate scores
                 ParallelUtil.runWithConcurrency(concurrency, steps, 3, 1, TimeUnit.SECONDS, pool);
 
                 // sync scores
-                System.out.println("[sync scores] iteration:" + iteration + ", steps:" + steps.size());
                 synchronizeScores();
                 ParallelUtil.runWithConcurrency(concurrency, steps, 3, 1, TimeUnit.SECONDS, pool);
 
                 // normalize deltas
-                System.out.println("[norm computation] iteration:" + iteration + ", steps:" + steps.size());
                 normalizeDeltas(iteration);
                 ParallelUtil.runWithConcurrency(concurrency, steps, 3, 1, TimeUnit.SECONDS, pool);
-
-                System.out.println("[iteration finished] iteration:" + iteration);
-                System.out.println("-------");
             }
         }
 
         private void normalizeDeltas(int iteration) {
-            double l2Norm = computeNorm(iteration);
+            double l2Norm = computeNorm();
 
             for (ComputeStep step : steps) {
                 step.prepareNormalizeDeltas(l2Norm, iteration);
             }
         }
 
-        private double computeNorm(int iteration) {
+        private double computeNorm() {
             double l2Norm = 0.0;
             for (ComputeStep step : steps) {
                 double[] deltas = step.deltas();
-                System.out.println("[norm computation] iteration:" + iteration + ", deltas:" + Arrays.toString(deltas));
                 l2Norm += Arrays.stream(deltas).map(score -> score * score).sum();
             }
 
             l2Norm = Math.sqrt(l2Norm);
 
-            System.out.println("[norm computation] iteration:" + iteration  + ", l2Norm: " + l2Norm );
-
             l2Norm = l2Norm <= 0 ? 1 : l2Norm;
             return l2Norm;
         }

core/src/main/java/org/neo4j/graphalgo/core/utils/ParallelUtil.java

@@ -671,7 +671,6 @@ private static void runWithConcurrency(
             int maxWaitRetries,
             TerminationFlag terminationFlag,
             ExecutorService executor) {
-        System.out.println("[ParallelUtil#runWithConcurrency] running with " + tasks.size() + " tasks" + ", and concurrency of " + concurrency);
         if (!canRunInParallel(executor)
                 || tasks.size() == 1
                 || concurrency <= 1) {
@@ -692,7 +691,6 @@ private static void runWithConcurrency(
         // generally assumes that tasks.size is notably larger than concurrency
         try {
             //noinspection StatementWithEmptyBody - add first concurrency tasks
-            System.out.println("[ParallelUtil#runWithConcurrency] submit tasks");
             while (concurrency-- > 0
                     && terminationFlag.running()
                     && completionService.trySubmit(ts));
@@ -701,15 +699,12 @@ private static void runWithConcurrency(
                 return;
             }
 
-            System.out.println("[ParallelUtil#runWithConcurrency] submit more tasks");
             // submit all remaining tasks
             int tries = 0;
             while (ts.hasNext()) {
                 if (completionService.hasTasks()) {
                     try {
-                        System.out.println("[ParallelUtil#runWithConcurrency] waiting for task to finish... " + executor);
                         completionService.awaitNext();
-                        System.out.println("[ParallelUtil#runWithConcurrency] task finished... " + executor);
                     } catch (ExecutionException e) {
                         error = Exceptions.chain(error, e.getCause());
                     } catch (CancellationException ignore) {
@@ -720,18 +715,15 @@ private static void runWithConcurrency(
                 }
                 if (!completionService.trySubmit(ts) && !completionService.hasTasks()) {
                     if (++tries >= maxWaitRetries) {
-                        System.out.println("[ParallelUtil#runWithConcurrency] exceeded max wait retries");
                         break;
                     }
                     LockSupport.parkNanos(waitNanos);
                 }
             }
 
-            System.out.println("[ParallelUtil#runWithConcurrency] wait for tasks");
             // wait for all tasks to finish
             while (completionService.hasTasks() && terminationFlag.running()) {
                 try {
-                    System.out.println("[ParallelUtil#runWithConcurrency] waiting for next task");
                     completionService.awaitNext();
                 } catch (ExecutionException e) {
                     error = Exceptions.chain(error, e.getCause());
@@ -743,7 +735,6 @@ private static void runWithConcurrency(
         } finally {
             finishRunWithConcurrency(completionService, error);
         }
-        System.out.println("[ParallelUtil#runWithConcurrency] finished running with " + tasks.size() + " tasks");
     }
 
     private static void finishRunWithConcurrency(
@@ -890,9 +881,7 @@ protected void done() {
             if (executor instanceof ThreadPoolExecutor) {
                 pool = (ThreadPoolExecutor) executor;
                 availableConcurrency = pool.getCorePoolSize();
-//                availableConcurrency = 2;
                 int capacity = Math.max(targetConcurrency, availableConcurrency) + 1;
-                System.out.println("[ParallelUtil#runWithConcurrency] capacity = " + capacity + " [target:" + targetConcurrency + ",available:" + availableConcurrency + "]");
                 completionQueue = new ArrayBlockingQueue<>(capacity);
             } else {
                 pool = null;
@@ -939,17 +928,7 @@ void cancelAll() {
         }
 
         private boolean canSubmit() {
-            int activeCount = 0;
-            boolean canSubmit = pool == null || (activeCount = pool.getActiveCount()) < availableConcurrency;
-
-            if(!canSubmit) {
-                System.out.println("[ParallelUtil#runWithConcurrency] unable to submit task and pool:" + pool + ", activeCount:" + activeCount + ", availableConcurrency:" + availableConcurrency);
-//                throw new RuntimeException();
-            } else {
-                System.out.println("[ParallelUtil#runWithConcurrency] submitted task and pool:" + pool + ", activeCount:" + activeCount + ", availableConcurrency:" + availableConcurrency);
-            }
-
-            return canSubmit;
+            return pool == null || pool.getActiveCount() < availableConcurrency;
         }
 
         private void stopFutures(Collection<Future<Void>> futures) {
@@ -1001,7 +980,6 @@ public T next() {
 
         void pushBack(T element) {
             if (pushedElement != null) {
-                System.out.println("[ParallelUtil#runWithConcurrency] unable to reschedule task");
                 throw new IllegalArgumentException("Cannot push back twice");
             }
             pushedElement = element;