diff --git a/include/profile.h b/include/profile.h new file mode 100644 index 0000000000..f779dfae59 --- /dev/null +++ b/include/profile.h @@ -0,0 +1,147 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2013 CERN + * @author Tomasz Wlostowski + * + * 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; either version 2 + * of the License, or (at your option) any later version. + * + * 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, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/** + * @file profile.h: + * @brief Simple profiling functions for measuring code execution time. + */ + +#ifndef __TPROFILE_H +#define __TPROFILE_H + +#include +#include + +/** + * Function rdtsc + * Returns processor's time-stamp counter. Main purpose is precise time measuring of code + * execution time. + * @return unsigned long long - Value of time-stamp counter. + */ +#if defined(__i386__) +static __inline__ unsigned long long rdtsc() +{ + unsigned long long int x; + __asm__ volatile ( ".byte 0x0f, 0x31" : "=A" ( x ) ); + + return x; +} + + +#elif defined(__x86_64__) +static __inline__ unsigned long long rdtsc() +{ + unsigned hi, lo; + __asm__ __volatile__ ( "rdtsc" : "=a" ( lo ), "=d" ( hi ) ); + + return ( (unsigned long long) lo ) | ( ( (unsigned long long) hi ) << 32 ); +} + + +#elif defined(__powerpc__) +static __inline__ unsigned long long rdtsc() +{ + unsigned long long int result = 0; + unsigned long int upper, lower, tmp; + __asm__ volatile ( + "0: \n" + "\tmftbu %0 \n" + "\tmftb %1 \n" + "\tmftbu %2 \n" + "\tcmpw %2,%0 \n" + "\tbne 0b \n" + : "=r" ( upper ), "=r" ( lower ), "=r" ( tmp ) + ); + + result = upper; + result = result << 32; + result = result | lower; + + return result; +} + + +#endif /* __powerpc__ */ + +// Fixme: OS X version +/** + * Function get_tics + * Returns the number of microseconds that have elapsed since the system was started. + * @return uint64_t Number of microseconds. + */ +static inline uint64_t get_tics() +{ + struct timeval tv; + gettimeofday( &tv, NULL ); + + return (uint64_t) tv.tv_sec * 1000000ULL + (uint64_t) tv.tv_usec; +} + + +/** + * Structure for storing data related to profiling counters. + */ +struct prof_counter +{ + uint64_t value; /// Stored timer value + bool use_rdtsc; /// Method of time measuring (rdtsc or tics) +}; + +/** + * Function prof_start + * Begins code execution time counting for a given profiling counter. + * @param cnt is the counter which should be started. + * @param use_rdtsc tells if processor's time-stamp counter should be used for time counting. + * Otherwise is system tics method will be used. IMPORTANT: time-stamp counter should not + * be used on multicore machines executing threaded code. + */ +static inline void prof_start( prof_counter* cnt, bool use_rdtsc ) +{ + cnt->use_rdtsc = use_rdtsc; + + if( use_rdtsc ) + { + cnt->value = rdtsc(); + } + else + { + cnt->value = get_tics(); + } +} + + +/** + * Function prof_stop + * Ends code execution time counting for a given profiling counter. + * @param cnt is the counter which should be stopped. + */ +static inline void prof_end( prof_counter* cnt ) +{ + if( cnt->use_rdtsc ) + cnt->value = rdtsc() - cnt->value; + else + cnt->value = get_tics() - cnt->value; +} + +#endif diff --git a/include/tool/tool_action.h b/include/tool/tool_action.h new file mode 100644 index 0000000000..e2eced3359 --- /dev/null +++ b/include/tool/tool_action.h @@ -0,0 +1,86 @@ +#ifndef __TOOL_ACTION_H +#define __TOOL_ACTION_H + +#include +#include + +#include + +///> Scope of tool actions +enum TOOL_ActionScope { + SCOPE_CONTEXT = 1, ///> Action belongs to a particular tool (i.e. a part of a pop-up menu) + SCOPE_GLOBAL ///> Global action (toolbar/main menu event, global shortcut) +}; + +// TOOL_ACTION - represents a single action. For instance: +// - changing layer to top by pressing PgUp +// - running the DRC from the menu +// and so on, and so forth.... +class TOOL_ACTION +{ + public: + + + TOOL_ACTION + ( + const std::string& name, + TOOL_ActionScope scope = SCOPE_GLOBAL, + int aDefaultHotKey = 0, + const wxString& menuItem = wxT(""), + const wxString& menuDesc = wxT("") + ) : + m_name(name), + m_scope(scope), + m_defaultHotKey(aDefaultHotKey), + m_currentHotKey(aDefaultHotKey), + m_menuItem(menuItem), + m_menuDescription(menuDesc) {} + + bool operator == ( const TOOL_ACTION& rhs ) const + { + return m_id == rhs.m_id; + } + + bool operator != ( const TOOL_ACTION& rhs ) const + { + return m_id != rhs.m_id; + } + + bool hasHotKey() const + { + return m_currentHotKey > 0; + } + + private: + friend class TOOL_MANAGER; + + void setId ( int aId ) + { + m_id = aId; + } + + + // name of the action (convention is: app.[tool.]action.name) + std::string m_name; + TOOL_ActionScope m_scope; + int m_defaultHotKey; + int m_currentHotKey; + + // Menu item text + wxString m_menuItem; + // Pop-up help + wxString m_menuDescription; + + //KiBitmap m_bitmap; + + // Unique ID for fast matching. Assigned by TOOL_MANAGER + int m_id; + + // Origin of the action + TOOL_BASE *m_origin; + + // Originating UI object + wxWindow *m_uiOrigin; +}; + +#endif