From 5b827e13413d9790981601522eb9fe5070e5615e Mon Sep 17 00:00:00 2001
From: Carl Worth <cworth@cworth.org>
Date: Sun, 12 Aug 2012 20:41:50 -0700
Subject: [PATCH] trim: Avoid doing any analysis past the end of the
 user-specified range.

This doesn't actually change any results, (the dependency analysis
already ensures that calls beyond the range won't get included).

But this is a nice optimization to prevent wasted time and memory
analyzing these calls that are really easy to reject.
---
 cli/cli_trim.cpp         | 24 ++++++++++++++++++++++++
 common/trace_callset.cpp |  4 ++--
 common/trace_callset.hpp | 24 +++++++++++++++++++++++-
 3 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/cli/cli_trim.cpp b/cli/cli_trim.cpp
index 1d2abff..3d57c7e 100644
--- a/cli/cli_trim.cpp
+++ b/cli/cli_trim.cpp
@@ -151,6 +151,18 @@ public:
 
     /* Compute and record all the resources provided by this call. */
     void analyze(trace::Call *call) {
+        /* If there are no side effects, this call provides nothing. */
+        if (call->flags & trace::CALL_FLAG_NO_SIDE_EFFECTS) {
+            return;
+        }
+
+        /* Similarly, calls that swap buffers don't have other side effects. */
+        if (call->flags & trace::CALL_FLAG_SWAP_RENDERTARGET &&
+            call->flags & trace::CALL_FLAG_END_FRAME) {
+            return;
+        }
+
+        /* By default, assume this call affects the state somehow. */
         resources["state"].insert(call->no);
     }
 
@@ -215,6 +227,12 @@ trim_trace(const char *filename, struct trim_options *options)
     /* In pass 1, analyze which calls are needed. */
     trace::Call *call;
     while ((call = p.parse_call())) {
+
+        /* There's no use doing any work past the last call requested
+         * by the user. */
+        if (call->no > options->calls.getLast())
+            break;
+
         /* If requested, ignore all calls not belonging to the specified thread. */
         if (options->thread != -1 && call->thread_id != options->thread)
             continue;
@@ -256,6 +274,12 @@ trim_trace(const char *filename, struct trim_options *options)
     required = analyzer.get_required();
 
     while ((call = p.parse_call())) {
+
+        /* There's no use doing any work past the last call requested
+         * by the user. */
+        if (call->no > options->calls.getLast())
+            break;
+
         if (required->find(call->no) != required->end()) {
             writer.writeCall(call);
         }
diff --git a/common/trace_callset.cpp b/common/trace_callset.cpp
index 3c33087..93d145f 100644
--- a/common/trace_callset.cpp
+++ b/common/trace_callset.cpp
@@ -224,7 +224,7 @@ public:
 };
 
 
-CallSet::CallSet(const char *string)
+CallSet::CallSet(const char *string): limits(std::numeric_limits<CallNo>::min(), std::numeric_limits<CallNo>::max())
 {
     if (*string == '@') {
         FileCallSetParser parser(*this, &string[1]);
@@ -236,7 +236,7 @@ CallSet::CallSet(const char *string)
 }
 
 
-CallSet::CallSet(CallFlags freq) {
+CallSet::CallSet(CallFlags freq): limits(std::numeric_limits<CallNo>::min(), std::numeric_limits<CallNo>::max()) {
     if (freq != FREQUENCY_NONE) {
         CallNo start = std::numeric_limits<CallNo>::min();
         CallNo stop = std::numeric_limits<CallNo>::max();
diff --git a/common/trace_callset.hpp b/common/trace_callset.hpp
index b679d94..4a4a52d 100644
--- a/common/trace_callset.hpp
+++ b/common/trace_callset.hpp
@@ -48,6 +48,7 @@
 #define _TRACE_CALLSET_HPP_
 
 
+#include <limits>
 #include <list>
 
 #include "trace_model.hpp"
@@ -106,12 +107,15 @@ namespace trace {
     // A collection of call ranges
     class CallSet
     {
+    private:
+        CallRange limits;
+
     public:
         // TODO: use binary tree to speed up lookups
         typedef std::list< CallRange > RangeList;
         RangeList ranges;
 
-        CallSet() {}
+        CallSet(): limits(std::numeric_limits<CallNo>::min(), std::numeric_limits<CallNo>::max()) {}
 
         CallSet(CallFlags freq);
 
@@ -128,6 +132,16 @@ namespace trace {
             if (range.start <= range.stop &&
                 range.freq != FREQUENCY_NONE) {
 
+                if (empty()) {
+                    limits.start = range.start;
+                    limits.stop = range.stop;
+                } else {
+                    if (range.start < limits.start)
+                        limits.start = range.start;
+                    if (range.stop > limits.stop)
+                        limits.stop = range.stop;
+                }
+
                 RangeList::iterator it = ranges.begin();
                 while (it != ranges.end() && it->start < range.start) {
                     ++it;
@@ -155,6 +169,14 @@ namespace trace {
         contains(const trace::Call &call) {
             return contains(call.no, call.flags);
         }
+
+        CallNo getFirst() {
+            return limits.start;
+        }
+
+        CallNo getLast() {
+            return limits.stop;
+        }
     };
 
 
-- 
2.43.0