Remember thread's task when sampling use it when filtering

runtime/vm/profiler.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_PROFILER_H_
 #define VM_PROFILER_H_
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/code_observers.h"
@@ skipping 73 matching lines @@
   Isolate* isolate_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
 
 class SampleFilter : public ValueObject {
  public:
   SampleFilter(Isolate* isolate,
+               intptr_t thread_task_mask,
                int64_t time_origin_micros,
                int64_t time_extent_micros)
       : isolate_(isolate),
+        thread_task_mask_(thread_task_mask),
         time_origin_micros_(time_origin_micros),
         time_extent_micros_(time_extent_micros) {
+    ASSERT(thread_task_mask != 0);
     ASSERT(time_origin_micros_ >= -1);
     ASSERT(time_extent_micros_ >= -1);
   }
   virtual ~SampleFilter() { }
 
   // Override this function.
   // Return |true| if |sample| passes the filter.
   virtual bool FilterSample(Sample* sample) {
     return true;
   }
 
   Isolate* isolate() const {
     return isolate_;
   }
 
   // Returns |true| if |sample| passes the time filter.
   bool TimeFilterSample(Sample* sample);
 
+  // Returns |true| if |sample| passes the thread task filter.
+  bool TaskFilterSample(Sample* sample);
+
  private:
   Isolate* isolate_;
-
+  intptr_t thread_task_mask_;
   int64_t time_origin_micros_;
   int64_t time_extent_micros_;
 };
 
 
 class ClearProfileVisitor : public SampleVisitor {
  public:
   explicit ClearProfileVisitor(Isolate* isolate);
 
   virtual void VisitSample(Sample* sample);
@@ skipping 137 matching lines @@
   }
 
   bool is_allocation_sample() const {
     return ClassAllocationSampleBit::decode(state_);
   }
 
   void set_is_allocation_sample(bool allocation_sample) {
     state_ = ClassAllocationSampleBit::update(allocation_sample, state_);
   }
 
-  bool is_mutator_thread() const {
-    return MutatorThreadBit::decode(state_);
+  Thread::TaskKind thread_task() const {
+    return ThreadTaskBit::decode(state_);
   }
 
-  void set_is_mutator_thread(bool mutator_thread) {
-    state_ = MutatorThreadBit::update(mutator_thread, state_);
+  void set_thread_task(Thread::TaskKind task) {
+    state_ = ThreadTaskBit::update(task, state_);
   }
 
   bool is_continuation_sample() const {
     return ContinuationSampleBit::decode(state_);
   }
 
   void SetContinuationIndex(intptr_t index) {
     ASSERT(!is_continuation_sample());
     ASSERT(continuation_index_ == -1);
     state_ = ContinuationSampleBit::update(true, state_);
@@ skipping 46 matching lines @@
   static intptr_t pcs_length_;
   enum StateBits {
     kHeadSampleBit = 0,
     kLeafFrameIsDartBit = 1,
     kIgnoreBit = 2,
     kExitFrameBit = 3,
     kMissingFrameInsertedBit = 4,
     kTruncatedTraceBit = 5,
     kClassAllocationSampleBit = 6,
     kContinuationSampleBit = 7,
-    kMutatorThreadBit = 8,
+    kThreadTaskBit = 8,  // 4 bits.
+    kNextFreeBit = 12,
   };
   class HeadSampleBit : public BitField<uword, bool, kHeadSampleBit, 1> {};
   class LeafFrameIsDart :
       public BitField<uword, bool, kLeafFrameIsDartBit, 1> {};
   class IgnoreBit : public BitField<uword, bool, kIgnoreBit, 1> {};
   class ExitFrameBit : public BitField<uword, bool, kExitFrameBit, 1> {};
   class MissingFrameInsertedBit
       : public BitField<uword, bool, kMissingFrameInsertedBit, 1> {};
   class TruncatedTraceBit :
       public BitField<uword, bool, kTruncatedTraceBit, 1> {};
   class ClassAllocationSampleBit
       : public BitField<uword, bool, kClassAllocationSampleBit, 1> {};
   class ContinuationSampleBit
       : public BitField<uword, bool, kContinuationSampleBit, 1> {};
-  class MutatorThreadBit
-      : public BitField<uword, bool, kMutatorThreadBit, 1> {};
+  class ThreadTaskBit
+      : public BitField<uword, Thread::TaskKind, kThreadTaskBit, 4> {};
 
   int64_t timestamp_;
   ThreadId tid_;
   Isolate* isolate_;
   uword pc_marker_;
   uword stack_buffer_[kStackBufferSizeInWords];
   uword vm_tag_;
   uword user_tag_;
   uword metadata_;
   uword lr_;
@@ skipping 268 matching lines @@
  private:
   ZoneGrowableArray<ProcessedSample*> samples_;
   CodeLookupTable* code_lookup_table_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
 };
 
 }  // namespace dart
 
 #endif  // VM_PROFILER_H_