cpufreq_interface.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *                         Powersave Daemon                                *
 *                                                                         *
 *          Copyright (C) 2004,2005,2006 SUSE Linux Products GmbH          *
 *                                                                         *
 *               Author(s): Holger Macht <hmacht@suse.de>                  *
 *                                                                         *
 * 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 you   *
 * 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, write to the Free Software Foundation, Inc., *
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA                  *
 *                                                                         *
 ***************************************************************************/

#ifndef POWERSAVE_CPUFREQ_H
#define POWERSAVE_CPUFREQ_H

#include "pm_interface.h"
#include "cpu.h"
#ifdef CPUFREQ_MEASURE
#include <time.h>
#endif

/* code in to test available speeds (initFreqsViaTesting())
   is converted from cpuspeed from Carl Thompson
   cpufreq.cc -> getspeeds() */

#define MAX_SPEEDS  20
#define MIN_SPEED_STEP 25000   /* in kHz, minimum step between 2 speeds */
#define SYSFS_FILES \
    "/sys/devices/system/cpu/"

class CPUFreq_Interface : public CPU {
public:
        CPUFreq_Interface(std::list< int > cpu_list);

        virtual ~CPUFreq_Interface();

        virtual bool init() = 0;

         virtual int adjustSpeed() = 0;

        virtual void reinitSpeed() = 0;

        virtual void setConfig() = 0;

        void setConfigs(int high_cpu, int max_limit, int hysters, int consider_nice);

        int setGovernor(const std::string &new_governor);


        int setMode(CPUFREQ_MODE mode);

        virtual bool readFrequencies() = 0;

        CPUFREQ_MODE getMode();

        static bool read_line(const char *filename, char *line, unsigned len);

        static bool write_line(const char *filename, const char *fmt, ...);

protected:

        static unsigned read_value(const char *filename);

        string GOVERNOR_FILE;

        string MIN_SPEED_FILE;

        string MAX_SPEED_FILE;

        string AVAILABLE_FREQS_FILE;

        int _cpu_max;

        int _cpu_hysteresis;

        int _high_cpu_limit;
        
        int _consider_nice;

        CPUFREQ_MODE _mode;

        std::list< int > _cpu_cores;
};

class CPUFreq_Userspace:public CPUFreq_Interface {
public:
         CPUFreq_Userspace(std::list< int > cpu_cores);

         ~CPUFreq_Userspace();

         bool init();

#ifdef CPUFREQ_MEASURE
    unsigned long time_spent[MAX_SPEEDS + 1];
    unsigned int count;
    unsigned long cpu_load_sum;

    static time_t *start_time;

    static unsigned long polling_interval;

    static void startMeasures();
    static void stopMeasures();

#endif

private:
        bool getMinMaxSpeeds(unsigned long *min, unsigned long *max);

        unsigned getSpeed();

        int increaseSpeed();

        int decreaseSpeed();

        bool setSpeed(unsigned kHz);

        void setSpeed(unsigned current, unsigned target);

        void createHysteresisArray();

        bool readFrequencies();

        int adjustSpeed();

        void reinitSpeed();

        int initFreqsViaFile();

        int initFreqsViaTesting();

        void setConfig();

        string CURRENT_SPEED_FILE;

        unsigned _speeds_kHz[MAX_SPEEDS + 1];

        unsigned _demotion[MAX_SPEEDS + 1];

        unsigned _current_speed;

        unsigned _new_speed;

        unsigned _last_step;

        int _last_cpu_load;

        string USERSPACE_STRING;
};

class CPUFreq_Kernel:public CPUFreq_Interface {
public:
         CPUFreq_Kernel(std::list< int > cpu_list, unsigned long sampling_rate = 333000);

        ~CPUFreq_Kernel();

        bool init();

private:
        bool readFrequencies();

        int adjustSpeed();

        void reinitSpeed();

        void setConfig();

        int writeOndemand(const string &name, int value);

        unsigned long _sampling_rate;

        int _down_threshold;

        int _sampling_down_factor;

        string ON_DEMAND_STRING;

        string POWERSAVE_STRING;

        string PERFORMANCE_STRING;
};

#endif  /* POWERSAVE_CPUFREQ_H */

---