pstats: Performance optimizations for strip chart

pandatool/src/pstatserver/pStatStripChart.cxx

@@ -188,7 +188,8 @@ set_auto_vertical_scale() {
 
     for (int frame_number = oldest_frame; frame_number <= latest_frame; ++frame_number) {
       if (thread_data->has_frame(frame_number)) {
-        values.push_back(get_net_value(frame_number));
+        const FrameData &frame = get_frame_data(frame_number);
+        values.push_back(frame._net_value);
       }
     }
   }
@@ -589,9 +590,15 @@ get_frame_data(int frame_number) const {
   }
 
   const PStatThreadData *thread_data = _view.get_thread_data();
-  _view.set_to_frame(thread_data->get_frame(frame_number));
+  const PStatFrameData &frame_data = thread_data->get_frame(frame_number);
+  _view.set_to_frame(frame_data);
 
   FrameData &fdata = _data[frame_number];
+  fdata._start = frame_data.get_start();
+  fdata._end = frame_data.get_end();
+  fdata._net_time = frame_data.get_net_time();
+
+  double net_value = 0.0;
 
   const PStatViewLevel *level = _view.get_level(_collector_index);
   int num_children = level->get_num_children();
@@ -604,6 +611,7 @@ get_frame_data(int frame_number) const {
     cd._net_value = child->get_net_value();
     if (cd._net_value != 0.0) {
       fdata.push_back(cd);
+      net_value += cd._net_value;
     }
   }
 
@@ -616,8 +624,11 @@ get_frame_data(int frame_number) const {
   cd._net_value = level->get_value_alone();
   if (cd._net_value > 0.0) {
     fdata.push_back(cd);
+    net_value += cd._net_value;
   }
 
+  fdata._net_value = net_value;
+
   ((PStatStripChart *)this)->inc_label_usage(fdata);
 
   return fdata;
@@ -645,34 +656,27 @@ compute_average_pixel_data(PStatStripChart::FrameData &result,
   }
 
   double then = now - pstats_average_time;
+  then_i = thread_data->get_frame_number_after(then, then_i);
+  now_i = thread_data->get_frame_number_after(now, now_i);
 
-  int latest_frame = thread_data->get_latest_frame_number();
-  while (then_i <= latest_frame &&
-         thread_data->get_frame(then_i).get_end() < then) {
-    then_i++;
-  }
-  while (now_i <= latest_frame &&
-         thread_data->get_frame(now_i).get_end() < now) {
-    now_i++;
-  }
-
-  then = max(then, thread_data->get_frame(then_i).get_start());
+  const FrameData &then_fdata = get_frame_data(then_i);
+  then = max(then, then_fdata._start);
+  double then_end = then_fdata._end;
 
   // Sum up a weighted average of all of the individual frames we pass.
 
   // We start with just the portion of frame then_i that actually does fall
   // within our "then to now" window.
-  accumulate_frame_data(result, get_frame_data(then_i),
-                        thread_data->get_frame(then_i).get_end() - then);
-  double last = thread_data->get_frame(then_i).get_end();
+  accumulate_frame_data(result, then_fdata, then_end - then);
+  double last = then_end;
 
   // Then we get all of each of the middle frames.
   for (int frame_number = then_i + 1;
        frame_number < now_i;
        frame_number++) {
-    accumulate_frame_data(result, get_frame_data(frame_number),
-                          thread_data->get_frame(frame_number).get_end() - last);
-    last = thread_data->get_frame(frame_number).get_end();
+    const FrameData &fdata = get_frame_data(frame_number);
+    accumulate_frame_data(result, fdata, fdata._end - last);
+    last = fdata._end;
   }
 
   // And finally, we get the remainder as now_i.
@@ -683,22 +687,6 @@ compute_average_pixel_data(PStatStripChart::FrameData &result,
   scale_frame_data(result, 1.0f / (now - then));
 }
 
-/**
- * Returns the net value of the chart's collector for the indicated frame
- * number.
- */
-double PStatStripChart::
-get_net_value(int frame_number) const {
-  const FrameData &frame = get_frame_data(frame_number);
-
-  double net_value = 0.0;
-  for (const ColorData &cd : frame) {
-    net_value += cd._net_value;
-  }
-
-  return net_value;
-}
-
 /**
  * Computes the average value of the chart's collector over the past
  * pstats_average_time number of seconds.
@@ -742,16 +730,18 @@ get_average_net_value() const {
     // within our "then to now" window (usually some portion of it will).
     const PStatFrameData &frame_data = thread_data->get_frame(then_i);
     if (frame_data.get_end() > then) {
-      double this_time = (frame_data.get_end() - then);
-      net_value += get_net_value(then_i) * this_time;
+      const FrameData &frame = get_frame_data(then_i);
+      double this_time = (frame._end - then);
+      net_value += frame._net_value * this_time;
       net_time += this_time;
     }
     // Then we get all of each of the remaining frames.
     for (int frame_number = then_i + 1;
          frame_number <= now_i;
          frame_number++) {
-      double this_time = thread_data->get_frame(frame_number).get_net_time();
-      net_value += get_net_value(frame_number) * this_time;
+      const FrameData &frame = get_frame_data(frame_number);
+      double this_time = frame._net_time;
+      net_value += frame._net_value * this_time;
       net_time += this_time;
     }
 

pandatool/src/pstatserver/pStatStripChart.h

@@ -86,7 +86,11 @@ protected:
     int _count;
     double _net_value;
   };
-  typedef pvector<ColorData> FrameData;
+  class FrameData : public pvector<ColorData> {
+  public:
+    double _start, _end;
+    double _net_value, _net_time;
+  };
   typedef pmap<int, FrameData> Data;
 
   static void accumulate_frame_data(FrameData &fdata,
@@ -96,8 +100,6 @@ protected:
   const FrameData &get_frame_data(int frame_number) const;
   void compute_average_pixel_data(PStatStripChart::FrameData &result,
                                   int &then_i, int &now_i, double now);
-  double get_net_value(int frame_number) const;
-  double get_net_value(int frame_number, int collector_index) const;
   double get_average_net_value() const;
 
   void changed_size(int xsize, int ysize);

pandatool/src/pstatserver/pStatThreadData.cxx

@@ -175,6 +175,28 @@ get_frame_number_at_time(double time, int hint) const {
   return _first_frame_number + i;
 }
 
+/**
+ * Returns the frame number of the first frame later than the indicated time
+ * and start frame number.
+ */
+int PStatThreadData::
+get_frame_number_after(double time, int start_at) const {
+  int i = std::max(0, start_at - _first_frame_number);
+  double end = get_frame(i).get_end();
+
+  while (end < time) {
+    ++i;
+    if (i >= _frames.size()) {
+      break;
+    }
+    if (_frames[i] != nullptr) {
+      end = _frames[i]->get_end();
+    }
+  }
+
+  return _first_frame_number + i;
+}
+
 /**
  * Returns the FrameData associated with the most recent frame.
  */

pandatool/src/pstatserver/pStatThreadData.h

@@ -51,6 +51,7 @@ public:
   double get_oldest_time() const;
   const PStatFrameData &get_frame_at_time(double time) const;
   int get_frame_number_at_time(double time, int hint = -1) const;
+  int get_frame_number_after(double time, int start_at = 0) const;
 
   const PStatFrameData &get_latest_frame() const;