Statistics.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2009-2010 Philipp Werner <philipp.werner@st.ovgu.de>
 * All rights reserved.
 *
 *    Redistribution and use in source and binary forms, with or without
 *    modification, are permitted provided that the following conditions
 *    are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *
 *    * Neither the name of the copyright holders nor the names of
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 *
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 *    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 *    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * $Id$
 *
 ******************************************************************************/

#ifndef __STATISTICS_H_2F8C97C9EC89D7__
#define __STATISTICS_H_2F8C97C9EC89D7__


#include <string.h>

#ifndef __AVR__
#include "boost/thread/mutex.hpp"
#endif


namespace famouso {
    namespace mw {
        namespace afp {
            namespace defrag {


                struct FragmentStats {
                    unsigned int expected;

                    unsigned int currently_expected;



                    unsigned int received;

                    unsigned int incorrect_header;

                    unsigned int outdated;

                    unsigned int used;

                    unsigned int duplicates;

                    FragmentStats() {
                        reset();
                    }

                    void reset() {
                        memset(this, 0, sizeof(*this));
                    }
                };


                struct EventStats {

                    unsigned int complete;

                    unsigned int incomplete;

                    EventStats() {
                        reset();
                    }

                    void reset() {
                        memset(this, 0, sizeof(*this));
                    }
                };



                template <class Tag>
                class Statistics {
                        // TODO: mutex als policy

                        static FragmentStats & fragment() {
                            static FragmentStats s;
                            return s;
                        }

                        static EventStats & event() {
                            static EventStats s;
                            return s;
                        }

#ifndef __AVR__
                        static boost::mutex & mutex() {
                            static boost::mutex m;
                            return m;
                        }
#endif

                        static void inc(unsigned int & val) {
#ifndef __AVR__
                            mutex().lock();
                            val++;
                            mutex().unlock();
#else
                            val++;
#endif
                        }

                        static void add(unsigned int & val, unsigned int to_add) {
#ifndef __AVR__
                            mutex().lock();
                            val += to_add;
                            mutex().unlock();
#else
                            val += to_add;
#endif
                        }

                        static void sub(unsigned int & val, unsigned int to_sub) {
#ifndef __AVR__
                            mutex().lock();
                            val -= to_sub;
                            mutex().unlock();
#else
                            val -= to_sub;
#endif
                        }

                    public:

                        static void fragment_received() {
                            inc(fragment().received);
                        }

                        static void fragment_incorrect_header() {
                            inc(fragment().incorrect_header);
                        }

                        static void fragment_outdated() {
                            inc(fragment().outdated);
                        }

                        static void fragment_duplicate() {
                            inc(fragment().duplicates);
                        }

                        static void fragment_used() {
                            inc(fragment().used);
                        }

                        static void fragments_expected(unsigned int n) {
                            add(fragment().expected, n);
                        }

                        static void fragments_currently_expected_add(unsigned int n) {
                            add(fragment().currently_expected, n);
                        }

                        static void fragments_currently_expected_sub(unsigned int n) {
                            sub(fragment().currently_expected, n);
                        }


                        static void event_complete()   {
                            inc(event().complete);
                        }

                        static void event_incomplete() {
                            inc(event().incomplete);
                        }


                        static void get_fragment_stats(FragmentStats & fs) {
#ifndef __AVR__
                            mutex().lock();
                            memcpy(&fs, &fragment(), sizeof(fs));
                            mutex().unlock();
#else
                            memcpy(&fs, &fragment(), sizeof(fs));
#endif
                        }

                        static void get_event_stats(EventStats & es) {
#ifndef __AVR__
                            mutex().lock();
                            memcpy(&es, &event(), sizeof(es));
                            mutex().unlock();
#else
                            memcpy(&es, &event(), sizeof(es));
#endif
                        }
                };



                class NoStatistics {
                    public:

                        static void fragment_received() {}

                        static void fragment_incorrect_header() {}

                        static void fragment_outdated() {}

                        static void fragment_duplicate() {}

                        static void fragment_used() {}

                        static void fragments_expected(unsigned int n) {}

                        static void fragments_currently_expected_add(unsigned int n) {}

                        static void fragments_currently_expected_sub(unsigned int n) {}


                        static void event_complete()   {}

                        static void event_incomplete() {}


                        static void get_fragment_stats(FragmentStats & fs) {
                        }

                        static void get_event_stats(EventStats & es) {
                        }
                };



            } // namespace defrag
        } // namespace afp
    } // namespace mw
} // namespace famouso


#endif // __STATISTICS_H_2F8C97C9EC89D7__