trace_buffer.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2016 Couchbase, Inc
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
#pragma once

#include <array>
#include <iterator>
#include <memory>
#include <thread>
#include <type_traits>
#include <vector>
#include <functional>

#include <gsl_p/iterator.h>

#include "phosphor/platform/core.h"
#include "trace_event.h"

namespace phosphor {

#ifndef PHOSPHOR_CHUNK_PAGE_COUNT
#define PHOSPHOR_CHUNK_PAGE_COUNT 1
#endif

    class PHOSPHOR_API TraceChunk {
    public:
        static constexpr auto chunk_page_count = PHOSPHOR_CHUNK_PAGE_COUNT;
        static constexpr auto page_size = 4096;
        static constexpr auto array_offset = 64;
        static constexpr auto chunk_size =
            (((page_size * chunk_page_count) - array_offset) /
             sizeof(TraceEvent));
        using event_array = std::array<TraceEvent, chunk_size>;

        using const_iterator = event_array::const_iterator;

        TraceChunk() = default;

        void reset();

        TraceEvent& addEvent();

        const TraceEvent& operator[](const int index) const;

        bool isFull() const;

        size_t count() const;

        const_iterator begin() const;

        const_iterator end() const;

    private:
        unsigned short next_free;
        event_array chunk;
    };

    // Forward decl
    class StatsCallback;

    class TraceBuffer {
    public:
        virtual ~TraceBuffer() = default;

        virtual TraceChunk* getChunk() = 0;

        virtual void returnChunk(TraceChunk& chunk) = 0;

        virtual bool isFull() const = 0;

        virtual void getStats(StatsCallback& addStats) const = 0;

        virtual const TraceChunk& operator[](const int index) const = 0;

        virtual size_t chunk_count() const = 0;

        virtual size_t getGeneration() const = 0;

        class PHOSPHOR_API chunk_iterator
            : public std::iterator<std::bidirectional_iterator_tag,
                                   TraceChunk> {
            using const_reference = const TraceChunk&;
            using const_pointer = const TraceChunk*;
            using _self = chunk_iterator;

        public:
            chunk_iterator() = default;
            chunk_iterator(const TraceBuffer& buffer_);
            chunk_iterator(const TraceBuffer& buffer_, size_t index_);
            const_reference operator*() const;
            const_pointer operator->() const;
            chunk_iterator& operator++();
            bool operator==(const chunk_iterator& other) const;
            bool operator!=(const chunk_iterator& other) const;

        protected:
            const TraceBuffer& buffer;
            size_t index;
        };

        virtual chunk_iterator chunk_begin() const = 0;

        virtual chunk_iterator chunk_end() const = 0;

        using event_iterator = gsl_p::multidimensional_iterator<chunk_iterator>;

        virtual event_iterator begin() const = 0;

        virtual event_iterator end() const = 0;

        class PHOSPHOR_API chunk_iterable {
        public:
            chunk_iterable(const TraceBuffer& buffer_) : buffer(buffer_) {}

            chunk_iterator begin() {
                return buffer.chunk_begin();
            }

            chunk_iterator end() {
                return buffer.chunk_end();
            }

        private:
            const TraceBuffer& buffer;
        };

        chunk_iterable chunks() const {
            return chunk_iterable(*this);
        }
    };

    using buffer_ptr = std::unique_ptr<TraceBuffer>;

    using trace_buffer_factory =
        std::function<buffer_ptr(size_t generation, size_t buffer_size)>;

    PHOSPHOR_API
    buffer_ptr make_fixed_buffer(size_t generation, size_t buffer_size);

    PHOSPHOR_API
    buffer_ptr make_ring_buffer(size_t generation, size_t buffer_size);
}