--- /dev/null
+//
+// ProcessSummary.hpp
+// KDBG
+//
+// Created by James McIlree on 4/23/13.
+// Copyright (c) 2014 Apple. All rights reserved.
+//
+
+#ifndef kdprof_ProcessSummary_hpp
+#define kdprof_ProcessSummary_hpp
+
+template <typename SIZE>
+class MachineProcess;
+
+template <typename SIZE>
+class MachineThread;
+
+template <typename SIZE>
+class CPUSummary;
+
+template <typename SIZE>
+class ProcessSummary {
+ public:
+ typedef std::unordered_set<ThreadSummary<SIZE>, ThreadSummaryHash<SIZE>, ThreadSummaryEqualTo<SIZE>> ThreadSummarySet;
+
+ protected:
+ const MachineProcess<SIZE>* _process;
+
+ AbsTime _total_run_time;
+ AbsTime _total_idle_time;
+ AbsTime _total_intr_time;
+ AbsTime _total_future_run_time;
+ AbsTime _total_wallclock_run_time;
+ AbsTime _total_vm_fault_time;
+ AbsTime _total_io_time;
+ AbsTime _total_jetsam_time;
+
+ uint32_t _context_switch_count;
+ uint32_t _count_idle_events;
+ uint32_t _count_intr_events;
+ uint32_t _count_vm_fault_events;
+ uint32_t _count_io_events;
+ bool _is_jetsam_killed;
+
+ uint64_t _io_bytes_completed;
+
+ ThreadSummarySet _thread_summaries;
+
+ std::vector<AbsInterval> _wallclock_run_intervals; // This is the actual wallclock run interval data.
+ std::vector<AbsInterval> _per_cpu_wallclock_run_intervals; // We need to accumulate intervals during summary generation, this is a temp buffer.
+
+ friend class Machine<SIZE>;
+ friend class CPUSummary<SIZE>;
+
+ void add_run_time(AbsTime time) { _total_run_time += time; }
+ void add_idle_time(AbsTime time) { _total_idle_time += time; _count_idle_events++; }
+ void add_intr_time(AbsTime time) { _total_intr_time += time; _count_intr_events++; }
+ void add_future_run_time(AbsTime time) { _total_future_run_time += time; }
+ void add_vm_fault_time(AbsTime time) { _total_vm_fault_time += time; _count_vm_fault_events++; }
+ void add_io_time(AbsTime time) { _total_io_time += time; _count_io_events++; }
+ void add_jetsam_time(AbsTime time) { _total_jetsam_time += time; }
+
+ void add_io_bytes_completed(typename SIZE::ptr_t bytes) { _io_bytes_completed += bytes; }
+
+ //
+ // Wallclock run intervals are added as each cpu timeline is walked.
+ // Between cpu(s), the results are accumulated to a single buffer
+ // After all cpus have been processed, the single buffer is summarized
+ //
+ void add_wallclock_run_interval(AbsInterval interval);
+ void accumulate_wallclock_run_intervals();
+ void summarize_wallclock_run_intervals();
+
+ void incr_context_switches() { _context_switch_count++; }
+
+ void set_jetsam_killed() { ASSERT(!_is_jetsam_killed, "Attempt to jetsam process twice"); _is_jetsam_killed = true; }
+
+ ThreadSummary<SIZE>* mutable_thread_summary(const MachineThread<SIZE>* thread) {
+ auto it = _thread_summaries.find(thread);
+ if (it == _thread_summaries.end()) {
+ // We create any thread summary that is missing.
+ auto insert_result = _thread_summaries.emplace(thread);
+ ASSERT(insert_result.second, "Sanity");
+ it = insert_result.first;
+ }
+
+ // NOTE! Because we are using a Set instead of a Map, STL wants
+ // the objects to be immutable. "it" refers to a const Record, to
+ // prevent us from changing the hash or equality of the Set. We
+ // know that the allowed set of mutations will not change these,
+ // and so we evil hack(tm) and cast away the const'ness.
+ return const_cast<ThreadSummary<SIZE>*>(&*it);
+ }
+
+ ThreadSummarySet& mutable_thread_summaries() { return _thread_summaries; }
+
+ public:
+ ProcessSummary(const MachineProcess<SIZE>* process) :
+ _process(process),
+ _context_switch_count(0),
+ _count_idle_events(0),
+ _count_intr_events(0),
+ _count_vm_fault_events(0),
+ _count_io_events(0),
+ _is_jetsam_killed(false),
+ _io_bytes_completed(0)
+ {
+ }
+
+ const MachineProcess<SIZE>* process() const { return _process; }
+
+ AbsTime total_time() const { return _total_run_time + _total_idle_time + _total_intr_time; }
+ AbsTime total_run_time() const { return _total_run_time; }
+ AbsTime total_idle_time() const { return _total_idle_time; }
+ AbsTime total_intr_time() const { return _total_intr_time; }
+ AbsTime total_future_run_time() const { return _total_future_run_time; }
+ AbsTime total_wallclock_run_time() const { return _total_wallclock_run_time; }
+ AbsTime total_vm_fault_time() const { return _total_vm_fault_time; }
+ AbsTime total_io_time() const { return _total_io_time; }
+ AbsTime total_jetsam_time() const { return _total_jetsam_time; }
+
+ AbsTime avg_on_cpu_time() const { return _total_run_time / _context_switch_count; }
+
+ uint32_t context_switches() const { return _context_switch_count; }
+ uint32_t num_idle_events() const { return _count_idle_events; }
+ uint32_t num_intr_events() const { return _count_intr_events; }
+ uint32_t num_vm_fault_events() const { return _count_vm_fault_events; }
+ uint32_t num_io_events() const { return _count_io_events; }
+ uint32_t num_processes_jetsammed() const { return _is_jetsam_killed ? 1 : 0; }
+
+ uint64_t io_bytes_completed() const { return _io_bytes_completed; }
+
+ const ThreadSummarySet& thread_summaries() const { return _thread_summaries; }
+
+ const ThreadSummary<SIZE>* thread_summary(const MachineThread<SIZE>* thread) const {
+ auto it = _thread_summaries.find(thread);
+ return (it == _thread_summaries.end()) ? NULL : &*it;
+ }
+
+ DEBUG_ONLY(void validate() const;)
+};
+
+template <typename SIZE>
+void ProcessSummary<SIZE>::add_wallclock_run_interval(AbsInterval interval) {
+ ASSERT(_per_cpu_wallclock_run_intervals.empty() || (_per_cpu_wallclock_run_intervals.back() < interval && !interval.intersects(_per_cpu_wallclock_run_intervals.back())), "Invariant violated");
+ _per_cpu_wallclock_run_intervals.emplace_back(interval);
+}
+
+template <typename SIZE>
+void ProcessSummary<SIZE>::accumulate_wallclock_run_intervals() {
+ _wallclock_run_intervals = trange_vector_union(_wallclock_run_intervals, _per_cpu_wallclock_run_intervals);
+ _per_cpu_wallclock_run_intervals.clear();
+ // We don't shrink_to_fit here as its expected another CPU's run intervals will be processed next.
+}
+
+template <typename SIZE>
+void ProcessSummary<SIZE>::summarize_wallclock_run_intervals() {
+ ASSERT(_per_cpu_wallclock_run_intervals.empty(), "Sanity");
+ _per_cpu_wallclock_run_intervals.shrink_to_fit();
+
+ ASSERT(_total_wallclock_run_time == 0, "Called more than once");
+
+ ASSERT(is_trange_vector_sorted_and_non_overlapping(_wallclock_run_intervals), "Sanity");
+
+ for (auto& interval : _wallclock_run_intervals) {
+ _total_wallclock_run_time += interval.length();
+ }
+
+ _wallclock_run_intervals.clear();
+ _wallclock_run_intervals.shrink_to_fit();
+}
+
+#if !defined(NDEBUG) && !defined(NS_BLOCK_ASSERTIONS)
+template <typename SIZE>
+void ProcessSummary<SIZE>::validate() const {
+ ASSERT(_total_wallclock_run_time <= _total_run_time, "Sanity");
+
+ for (const auto& thread_summary : _thread_summaries) {
+ thread_summary.validate();
+ }
+}
+#endif
+
+template <typename SIZE>
+struct ProcessSummaryHash {
+ size_t operator()(const ProcessSummary<SIZE>& summary) const {
+ return std::hash<const MachineProcess<SIZE>*>()(summary.process());
+ }
+};
+
+template <typename SIZE>
+struct ProcessSummaryEqualTo {
+ bool operator()(const ProcessSummary<SIZE>& s1, const ProcessSummary<SIZE>& s2) const {
+ return s1.process() == s2.process();
+ }
+};
+
+#endif
projects / apple / system_cmds.git / blobdiff