| // Copyright 2015 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "base/trace_event/trace_buffer.h" | |
| #include <memory> | |
| #include <utility> | |
| #include <vector> | |
| #include "base/macros.h" | |
| #include "base/trace_event/heap_profiler.h" | |
| #include "base/trace_event/trace_event_impl.h" | |
| namespace base { | |
| namespace trace_event { | |
| namespace { | |
| class TraceBufferRingBuffer : public TraceBuffer { | |
| public: | |
| TraceBufferRingBuffer(size_t max_chunks) | |
| : max_chunks_(max_chunks), | |
| recyclable_chunks_queue_(new size_t[queue_capacity()]), | |
| queue_head_(0), | |
| queue_tail_(max_chunks), | |
| current_iteration_index_(0), | |
| current_chunk_seq_(1) { | |
| chunks_.reserve(max_chunks); | |
| for (size_t i = 0; i < max_chunks; ++i) | |
| recyclable_chunks_queue_[i] = i; | |
| } | |
| std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override { | |
| HEAP_PROFILER_SCOPED_IGNORE; | |
| // Because the number of threads is much less than the number of chunks, | |
| // the queue should never be empty. | |
| DCHECK(!QueueIsEmpty()); | |
| *index = recyclable_chunks_queue_[queue_head_]; | |
| queue_head_ = NextQueueIndex(queue_head_); | |
| current_iteration_index_ = queue_head_; | |
| if (*index >= chunks_.size()) | |
| chunks_.resize(*index + 1); | |
| TraceBufferChunk* chunk = chunks_[*index].release(); | |
| chunks_[*index] = nullptr; // Put nullptr in the slot of a in-flight chunk. | |
| if (chunk) | |
| chunk->Reset(current_chunk_seq_++); | |
| else | |
| chunk = new TraceBufferChunk(current_chunk_seq_++); | |
| return std::unique_ptr<TraceBufferChunk>(chunk); | |
| } | |
| void ReturnChunk(size_t index, | |
| std::unique_ptr<TraceBufferChunk> chunk) override { | |
| // When this method is called, the queue should not be full because it | |
| // can contain all chunks including the one to be returned. | |
| DCHECK(!QueueIsFull()); | |
| DCHECK(chunk); | |
| DCHECK_LT(index, chunks_.size()); | |
| DCHECK(!chunks_[index]); | |
| chunks_[index] = std::move(chunk); | |
| recyclable_chunks_queue_[queue_tail_] = index; | |
| queue_tail_ = NextQueueIndex(queue_tail_); | |
| } | |
| bool IsFull() const override { return false; } | |
| size_t Size() const override { | |
| // This is approximate because not all of the chunks are full. | |
| return chunks_.size() * TraceBufferChunk::kTraceBufferChunkSize; | |
| } | |
| size_t Capacity() const override { | |
| return max_chunks_ * TraceBufferChunk::kTraceBufferChunkSize; | |
| } | |
| TraceEvent* GetEventByHandle(TraceEventHandle handle) override { | |
| if (handle.chunk_index >= chunks_.size()) | |
| return nullptr; | |
| TraceBufferChunk* chunk = chunks_[handle.chunk_index].get(); | |
| if (!chunk || chunk->seq() != handle.chunk_seq) | |
| return nullptr; | |
| return chunk->GetEventAt(handle.event_index); | |
| } | |
| const TraceBufferChunk* NextChunk() override { | |
| if (chunks_.empty()) | |
| return nullptr; | |
| while (current_iteration_index_ != queue_tail_) { | |
| size_t chunk_index = recyclable_chunks_queue_[current_iteration_index_]; | |
| current_iteration_index_ = NextQueueIndex(current_iteration_index_); | |
| if (chunk_index >= chunks_.size()) // Skip uninitialized chunks. | |
| continue; | |
| DCHECK(chunks_[chunk_index]); | |
| return chunks_[chunk_index].get(); | |
| } | |
| return nullptr; | |
| } | |
| void EstimateTraceMemoryOverhead( | |
| TraceEventMemoryOverhead* overhead) override { | |
| overhead->Add(TraceEventMemoryOverhead::kTraceBuffer, sizeof(*this)); | |
| for (size_t queue_index = queue_head_; queue_index != queue_tail_; | |
| queue_index = NextQueueIndex(queue_index)) { | |
| size_t chunk_index = recyclable_chunks_queue_[queue_index]; | |
| if (chunk_index >= chunks_.size()) // Skip uninitialized chunks. | |
| continue; | |
| chunks_[chunk_index]->EstimateTraceMemoryOverhead(overhead); | |
| } | |
| } | |
| private: | |
| bool QueueIsEmpty() const { return queue_head_ == queue_tail_; } | |
| size_t QueueSize() const { | |
| return queue_tail_ > queue_head_ | |
| ? queue_tail_ - queue_head_ | |
| : queue_tail_ + queue_capacity() - queue_head_; | |
| } | |
| bool QueueIsFull() const { return QueueSize() == queue_capacity() - 1; } | |
| size_t queue_capacity() const { | |
| // One extra space to help distinguish full state and empty state. | |
| return max_chunks_ + 1; | |
| } | |
| size_t NextQueueIndex(size_t index) const { | |
| index++; | |
| if (index >= queue_capacity()) | |
| index = 0; | |
| return index; | |
| } | |
| size_t max_chunks_; | |
| std::vector<std::unique_ptr<TraceBufferChunk>> chunks_; | |
| std::unique_ptr<size_t[]> recyclable_chunks_queue_; | |
| size_t queue_head_; | |
| size_t queue_tail_; | |
| size_t current_iteration_index_; | |
| uint32_t current_chunk_seq_; | |
| DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer); | |
| }; | |
| class TraceBufferVector : public TraceBuffer { | |
| public: | |
| TraceBufferVector(size_t max_chunks) | |
| : in_flight_chunk_count_(0), | |
| current_iteration_index_(0), | |
| max_chunks_(max_chunks) { | |
| chunks_.reserve(max_chunks_); | |
| } | |
| std::unique_ptr<TraceBufferChunk> GetChunk(size_t* index) override { | |
| HEAP_PROFILER_SCOPED_IGNORE; | |
| // This function may be called when adding normal events or indirectly from | |
| // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we | |
| // have to add the metadata events and flush thread-local buffers even if | |
| // the buffer is full. | |
| *index = chunks_.size(); | |
| // Put nullptr in the slot of a in-flight chunk. | |
| chunks_.push_back(nullptr); | |
| ++in_flight_chunk_count_; | |
| // + 1 because zero chunk_seq is not allowed. | |
| return std::unique_ptr<TraceBufferChunk>( | |
| new TraceBufferChunk(static_cast<uint32_t>(*index) + 1)); | |
| } | |
| void ReturnChunk(size_t index, | |
| std::unique_ptr<TraceBufferChunk> chunk) override { | |
| DCHECK_GT(in_flight_chunk_count_, 0u); | |
| DCHECK_LT(index, chunks_.size()); | |
| DCHECK(!chunks_[index]); | |
| --in_flight_chunk_count_; | |
| chunks_[index] = std::move(chunk); | |
| } | |
| bool IsFull() const override { return chunks_.size() >= max_chunks_; } | |
| size_t Size() const override { | |
| // This is approximate because not all of the chunks are full. | |
| return chunks_.size() * TraceBufferChunk::kTraceBufferChunkSize; | |
| } | |
| size_t Capacity() const override { | |
| return max_chunks_ * TraceBufferChunk::kTraceBufferChunkSize; | |
| } | |
| TraceEvent* GetEventByHandle(TraceEventHandle handle) override { | |
| if (handle.chunk_index >= chunks_.size()) | |
| return nullptr; | |
| TraceBufferChunk* chunk = chunks_[handle.chunk_index].get(); | |
| if (!chunk || chunk->seq() != handle.chunk_seq) | |
| return nullptr; | |
| return chunk->GetEventAt(handle.event_index); | |
| } | |
| const TraceBufferChunk* NextChunk() override { | |
| while (current_iteration_index_ < chunks_.size()) { | |
| // Skip in-flight chunks. | |
| const TraceBufferChunk* chunk = chunks_[current_iteration_index_++].get(); | |
| if (chunk) | |
| return chunk; | |
| } | |
| return nullptr; | |
| } | |
| void EstimateTraceMemoryOverhead( | |
| TraceEventMemoryOverhead* overhead) override { | |
| const size_t chunks_ptr_vector_allocated_size = | |
| sizeof(*this) + max_chunks_ * sizeof(decltype(chunks_)::value_type); | |
| const size_t chunks_ptr_vector_resident_size = | |
| sizeof(*this) + chunks_.size() * sizeof(decltype(chunks_)::value_type); | |
| overhead->Add(TraceEventMemoryOverhead::kTraceBuffer, | |
| chunks_ptr_vector_allocated_size, | |
| chunks_ptr_vector_resident_size); | |
| for (size_t i = 0; i < chunks_.size(); ++i) { | |
| TraceBufferChunk* chunk = chunks_[i].get(); | |
| // Skip the in-flight (nullptr) chunks. They will be accounted by the | |
| // per-thread-local dumpers, see ThreadLocalEventBuffer::OnMemoryDump. | |
| if (chunk) | |
| chunk->EstimateTraceMemoryOverhead(overhead); | |
| } | |
| } | |
| private: | |
| size_t in_flight_chunk_count_; | |
| size_t current_iteration_index_; | |
| size_t max_chunks_; | |
| std::vector<std::unique_ptr<TraceBufferChunk>> chunks_; | |
| DISALLOW_COPY_AND_ASSIGN(TraceBufferVector); | |
| }; | |
| } // namespace | |
| TraceBufferChunk::TraceBufferChunk(uint32_t seq) : next_free_(0), seq_(seq) {} | |
| TraceBufferChunk::~TraceBufferChunk() = default; | |
| void TraceBufferChunk::Reset(uint32_t new_seq) { | |
| for (size_t i = 0; i < next_free_; ++i) | |
| chunk_[i].Reset(); | |
| next_free_ = 0; | |
| seq_ = new_seq; | |
| cached_overhead_estimate_.reset(); | |
| } | |
| TraceEvent* TraceBufferChunk::AddTraceEvent(size_t* event_index) { | |
| DCHECK(!IsFull()); | |
| *event_index = next_free_++; | |
| return &chunk_[*event_index]; | |
| } | |
| void TraceBufferChunk::EstimateTraceMemoryOverhead( | |
| TraceEventMemoryOverhead* overhead) { | |
| if (!cached_overhead_estimate_) { | |
| cached_overhead_estimate_.reset(new TraceEventMemoryOverhead); | |
| // When estimating the size of TraceBufferChunk, exclude the array of trace | |
| // events, as they are computed individually below. | |
| cached_overhead_estimate_->Add(TraceEventMemoryOverhead::kTraceBufferChunk, | |
| sizeof(*this) - sizeof(chunk_)); | |
| } | |
| const size_t num_cached_estimated_events = | |
| cached_overhead_estimate_->GetCount( | |
| TraceEventMemoryOverhead::kTraceEvent); | |
| DCHECK_LE(num_cached_estimated_events, size()); | |
| if (IsFull() && num_cached_estimated_events == size()) { | |
| overhead->Update(*cached_overhead_estimate_); | |
| return; | |
| } | |
| for (size_t i = num_cached_estimated_events; i < size(); ++i) | |
| chunk_[i].EstimateTraceMemoryOverhead(cached_overhead_estimate_.get()); | |
| if (IsFull()) { | |
| cached_overhead_estimate_->AddSelf(); | |
| } else { | |
| // The unused TraceEvents in |chunks_| are not cached. They will keep | |
| // changing as new TraceEvents are added to this chunk, so they are | |
| // computed on the fly. | |
| const size_t num_unused_trace_events = capacity() - size(); | |
| overhead->Add(TraceEventMemoryOverhead::kUnusedTraceEvent, | |
| num_unused_trace_events * sizeof(TraceEvent)); | |
| } | |
| overhead->Update(*cached_overhead_estimate_); | |
| } | |
| TraceResultBuffer::OutputCallback | |
| TraceResultBuffer::SimpleOutput::GetCallback() { | |
| return Bind(&SimpleOutput::Append, Unretained(this)); | |
| } | |
| void TraceResultBuffer::SimpleOutput::Append( | |
| const std::string& json_trace_output) { | |
| json_output += json_trace_output; | |
| } | |
| TraceResultBuffer::TraceResultBuffer() : append_comma_(false) {} | |
| TraceResultBuffer::~TraceResultBuffer() = default; | |
| void TraceResultBuffer::SetOutputCallback( | |
| const OutputCallback& json_chunk_callback) { | |
| output_callback_ = json_chunk_callback; | |
| } | |
| void TraceResultBuffer::Start() { | |
| append_comma_ = false; | |
| output_callback_.Run("["); | |
| } | |
| void TraceResultBuffer::AddFragment(const std::string& trace_fragment) { | |
| if (append_comma_) | |
| output_callback_.Run(","); | |
| append_comma_ = true; | |
| output_callback_.Run(trace_fragment); | |
| } | |
| void TraceResultBuffer::Finish() { | |
| output_callback_.Run("]"); | |
| } | |
| TraceBuffer* TraceBuffer::CreateTraceBufferRingBuffer(size_t max_chunks) { | |
| return new TraceBufferRingBuffer(max_chunks); | |
| } | |
| TraceBuffer* TraceBuffer::CreateTraceBufferVectorOfSize(size_t max_chunks) { | |
| return new TraceBufferVector(max_chunks); | |
| } | |
| } // namespace trace_event | |
| } // namespace base |