ut0counter.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 2012, Oracle and/or its affiliates. All Rights Reserved.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/**************************************************/
#ifndef UT0COUNTER_H
#define UT0COUNTER_H

#include "univ.i"
#include <string.h>
#include "os0thread.h"

#define CACHE_LINE_SIZE         64

#define IB_N_SLOTS              64

template <typename Type, int N>
struct generic_indexer_t {
        size_t offset(size_t index) const UNIV_NOTHROW {
                return(((index % N) + 1) * (CACHE_LINE_SIZE / sizeof(Type)));
        }
};

#ifdef HAVE_SCHED_GETCPU
#include <utmpx.h>
template <typename Type, int N>
struct get_sched_indexer_t : public generic_indexer_t<Type, N> {
        /* @return result from sched_getcpu(), the thread id if it fails. */
        size_t get_rnd_index() const UNIV_NOTHROW {

                size_t  cpu = sched_getcpu();
                if (cpu == -1) {
                        cpu = (lint) os_thread_get_curr_id();
                }

                return(cpu);
        }
};
#endif /* HAVE_SCHED_GETCPU */

template <typename Type, int N>
struct thread_id_indexer_t : public generic_indexer_t<Type, N> {
        /* @return a random number, currently we use the thread id. Where
        thread id is represented as a pointer, it may not work as
        effectively. */
        size_t get_rnd_index() const UNIV_NOTHROW {
                return((lint) os_thread_get_curr_id());
        }
};

template <typename Type, int N=1>
struct single_indexer_t {
        size_t offset(size_t index) const UNIV_NOTHROW {
                ut_ad(N == 1);
                return((CACHE_LINE_SIZE / sizeof(Type)));
        }

        /* @return 1 */
        size_t get_rnd_index() const UNIV_NOTHROW {
                ut_ad(N == 1);
                return(1);
        }
};

template <
        typename Type,
        int N = IB_N_SLOTS,
        template<typename, int> class Indexer = thread_id_indexer_t>
class ib_counter_t {
public:
        ib_counter_t() { memset(m_counter, 0x0, sizeof(m_counter)); }

        ~ib_counter_t()
        {
                ut_ad(validate());
        }

        bool validate() UNIV_NOTHROW {
#ifdef UNIV_DEBUG
                size_t  n = (CACHE_LINE_SIZE / sizeof(Type));

                /* Check that we aren't writing outside our defined bounds. */
                for (size_t i = 0; i < UT_ARR_SIZE(m_counter); i += n) {
                        for (size_t j = 1; j < n - 1; ++j) {
                                ut_ad(m_counter[i + j] == 0);
                        }
                }
#endif /* UNIV_DEBUG */
                return(true);
        }

        void inc() UNIV_NOTHROW { add(1); }

        void add(Type n) UNIV_NOTHROW {
                size_t  i = m_policy.offset(m_policy.get_rnd_index());

                ut_ad(i < UT_ARR_SIZE(m_counter));

                m_counter[i] += n;
        }

        void add(size_t index, Type n) UNIV_NOTHROW {
                size_t  i = m_policy.offset(index);

                ut_ad(i < UT_ARR_SIZE(m_counter));

                m_counter[i] += n;
        }

        void dec() UNIV_NOTHROW { sub(1); }

        void sub(Type n) UNIV_NOTHROW {
                size_t  i = m_policy.offset(m_policy.get_rnd_index());

                ut_ad(i < UT_ARR_SIZE(m_counter));

                m_counter[i] -= n;
        }

        void sub(size_t index, Type n) UNIV_NOTHROW {
                size_t  i = m_policy.offset(index);

                ut_ad(i < UT_ARR_SIZE(m_counter));

                m_counter[i] -= n;
        }

        /* @return total value - not 100% accurate, since it is not atomic. */
        operator Type() const UNIV_NOTHROW {
                Type    total = 0;

                for (size_t i = 0; i < N; ++i) {
                        total += m_counter[m_policy.offset(i)];
                }

                return(total);
        }

private:
        Indexer<Type, N>m_policy;

        Type            m_counter[(N + 1) * (CACHE_LINE_SIZE / sizeof(Type))];
};

#endif /* UT0COUNTER_H */