BazelProfile: precompute some fields

Some of the getters (getCriticalPath(), etc.) used to run in O(N) for
N=threads.size(); now they are O(1) because we precompute what they'd
return.

Also, BazelProfile's members are no longer mutable, meaning we can
safely precompute those values without fear of staleness.

Signed-off-by: László Csomor <laszlo@engflow.com>

Author: laszlocsomor

analyzer/java/com/engflow/bazel/invocation/analyzer/bazelprofile/BazelProfile.java

@@ -24,6 +24,7 @@
 import com.engflow.bazel.invocation.analyzer.traceeventformat.CounterEvent;
 import com.engflow.bazel.invocation.analyzer.traceeventformat.TraceEventFormatConstants;
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -78,15 +79,35 @@ public static BazelProfile createFromPath(String path) throws IllegalArgumentExc
 
   public static BazelProfile createFromInputStream(InputStream inputStream)
       throws IllegalArgumentException {
-    return new BazelProfile(
+    return BazelProfile.create(
         new JsonReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)));
   }
 
   private final BazelVersion bazelVersion;
-  private final Map<String, String> otherData = new HashMap<>();
-  private final Map<ThreadId, ProfileThread> threads = new HashMap<>();
+  private final ImmutableMap<String, String> otherData;
+  private final ImmutableMap<ThreadId, ProfileThread> threads;
+  private final ProfileThread mainThread;
+  private final Optional<ProfileThread> criticalPath;
+  private final Optional<ProfileThread> gcThread;
+
+  private BazelProfile(
+      BazelVersion bazelVersion,
+      ImmutableMap<String, String> otherData,
+      ImmutableMap<ThreadId, ProfileThread> threads,
+      ProfileThread mainThread,
+      Optional<ProfileThread> criticalPath,
+      Optional<ProfileThread> gcThread) {
+    this.bazelVersion = Preconditions.checkNotNull(bazelVersion);
+    this.otherData = Preconditions.checkNotNull(otherData);
+    this.threads = Preconditions.checkNotNull(threads);
+    this.mainThread = Preconditions.checkNotNull(mainThread);
+    this.criticalPath = Preconditions.checkNotNull(criticalPath);
+    this.gcThread = Preconditions.checkNotNull(gcThread);
+  }
 
-  private BazelProfile(JsonReader profileReader) {
+  private static BazelProfile create(JsonReader profileReader) {
+    Map<String, String> otherData = new HashMap<>();
+    Map<ThreadId, ProfileThread> threads = new HashMap<>();
     try {
       boolean hasOtherData = false;
       boolean hasTraceEvents = false;
@@ -116,15 +137,11 @@ private BazelProfile(JsonReader profileReader) {
                 continue;
               }
               ThreadId threadId = new ThreadId(pid, tid);
-              ProfileThread profileThread =
-                  threads.compute(
-                      threadId,
-                      (key, t) -> {
-                        if (t == null) {
-                          t = new ProfileThread(threadId);
-                        }
-                        return t;
-                      });
+              ProfileThread profileThread = threads.get(threadId);
+              if (profileThread == null) {
+                profileThread = new ProfileThread(threadId);
+                threads.put(threadId, profileThread);
+              }
               // TODO: Use success response to take action on errant events.
               profileThread.addEvent(traceEvent);
             }
@@ -147,23 +164,34 @@ private BazelProfile(JsonReader profileReader) {
       throw new IllegalArgumentException("Could not parse Bazel profile.", e);
     }
 
-    this.bazelVersion =
+    BazelVersion bazelVersion =
         BazelVersion.parse(otherData.get(BazelProfileConstants.OTHER_DATA_BAZEL_VERSION));
+    ProfileThread mainThread = null;
+    ProfileThread criticalPath = null;
+    ProfileThread gcThread = null;
+    for (ProfileThread e : threads.values()) {
+      if (mainThread == null && isMainThread(e)) {
+        mainThread = e;
+      } else if (criticalPath == null && isCriticalPathThread(e)) {
+        criticalPath = e;
+      } else if (gcThread == null && isGarbageCollectorThread(e)) {
+        gcThread = e;
+      }
+    }
 
-    if (!containsMainThread()) {
+    if (mainThread == null) {
       throw new IllegalArgumentException(
           String.format(
               "Invalid Bazel profile, JSON file missing \"%s\".",
               BazelProfileConstants.THREAD_MAIN));
     }
-  }
-
-  /**
-   * This method is called from the constructor. Either it needs to stay private or it must be
-   * declared final, so that it cannot be overridden.
-   */
-  private boolean containsMainThread() {
-    return threads.values().stream().anyMatch(BazelProfile::isMainThread);
+    return new BazelProfile(
+        bazelVersion,
+        ImmutableMap.copyOf(otherData),
+        ImmutableMap.copyOf(threads),
+        mainThread,
+        Optional.ofNullable(criticalPath),
+        Optional.ofNullable(gcThread));
   }
 
   /**
@@ -228,15 +256,15 @@ public Stream<ProfileThread> getThreads() {
   }
 
   public Optional<ProfileThread> getCriticalPath() {
-    return threads.values().stream().filter(BazelProfile::isCriticalPathThread).findAny();
+    return criticalPath;
   }
 
   public ProfileThread getMainThread() {
-    return threads.values().stream().filter(BazelProfile::isMainThread).findAny().get();
+    return mainThread;
   }
 
   public Optional<ProfileThread> getGarbageCollectorThread() {
-    return threads.values().stream().filter(BazelProfile::isGarbageCollectorThread).findAny();
+    return gcThread;
   }
 
   public Optional<ImmutableList<CounterEvent>> getActionCounts() {