PowerSpicedComponent Class Reference

#include <PowerSpicedComponent.h>

Public Member Functions
PowerCallibInputs *	add_entry (int num_inputs)
PowerCallibInputs *	get_entry (int num_inputs)
PowerCallibInputs *	get_entry_bound (bool lower, int num_inputs)
	PowerSpicedComponent (float(*usage_fn)(int num_inputs, float transistor_size))
void	add_data_point (int num_inputs, float transistor_size, float power)
float	scale_factor (int num_inputs, float transistor_size)
void	sort_me ()
void	callibrate (void)
bool	is_done_callibration (void)

Data Fields
std::vector< PowerCallibInputs * >	entries
float(*	component_usage )(int num_inputs, float transistor_size)
bool	sorted
bool	done_callibration

Detailed Description

Definition at line 56 of file PowerSpicedComponent.h.

Constructor & Destructor Documentation

PowerSpicedComponent::PowerSpicedComponent

(

float(*)(int num_inputs, float transistor_size)

usage_fn

)

Definition at line 76 of file PowerSpicedComponent.c.

                                                                  {
    component_usage = usage_fn;

    /* Always pad with a high and low entry */
    add_entry(0);
//  add_entry(std::numeric_limits<int>::max());
    add_entry(1000000000);

    done_callibration = false;
    sorted = true;
}

Here is the call graph for this function:

Member Function Documentation

void PowerSpicedComponent::add_data_point	(	int	num_inputs,
		float	transistor_size,
		float	power
	)

Definition at line 136 of file PowerSpicedComponent.c.

                     {
    assert(!done_callibration);
    PowerCallibInputs * inputs_entry = get_entry(num_inputs);
    inputs_entry->add_size(transistor_size, power);
    sorted = false;
}

Here is the call graph for this function:

PowerCallibInputs * PowerSpicedComponent::add_entry

(

int

num_inputs

)

Definition at line 89 of file PowerSpicedComponent.c.

                                                                  {
    PowerCallibInputs * entry = new PowerCallibInputs(this, num_inputs);
    entries.push_back(entry);
    return entry;
}

Here is the caller graph for this function:

void PowerSpicedComponent::callibrate

(

void

)

Definition at line 218 of file PowerSpicedComponent.c.

                                          {
    sort_me();

    for (vector<PowerCallibInputs*>::iterator it = entries.begin();
            it != entries.end(); it++) {
        (*it)->callibrate();
    }
    done_callibration = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PowerCallibInputs * PowerSpicedComponent::get_entry

(

int

num_inputs

)

Definition at line 95 of file PowerSpicedComponent.c.

                                                                  {
    vector<PowerCallibInputs*>::iterator it;

    for (it = entries.begin(); it != entries.end(); it++) {
        if ((*it)->num_inputs == num_inputs) {
            break;
        }
    }

    if (it == entries.end()) {
        return add_entry(num_inputs);
    } else {
        return *it;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PowerCallibInputs * PowerSpicedComponent::get_entry_bound	(	bool	lower,
		int	num_inputs
	)

Definition at line 111 of file PowerSpicedComponent.c.

                        {
    PowerCallibInputs * prev = entries[0];

    assert(sorted);
    for (vector<PowerCallibInputs*>::iterator it = entries.begin() + 1;
            it != entries.end(); it++) {
        if ((*it)->num_inputs > num_inputs) {
            if (lower) {
                if (prev == entries[0])
                    return NULL;
                else
                    return prev;
            } else {
                if (*it == entries[entries.size() - 1])
                    return NULL;
                else
                    return *it;
            }
        }
        prev = *it;
    }
    return NULL;
}

Here is the caller graph for this function:

bool PowerSpicedComponent::is_done_callibration

(

void

)

Definition at line 228 of file PowerSpicedComponent.c.

                                                    {
    return done_callibration;
}

Here is the caller graph for this function:

float PowerSpicedComponent::scale_factor	(	int	num_inputs,
		float	transistor_size
	)

Definition at line 144 of file PowerSpicedComponent.c.

                               {

    PowerCallibInputs * inputs_lower;
    PowerCallibInputs * inputs_upper;

    PowerCallibSize * size_lower;
    PowerCallibSize * size_upper;

    float factor_lower = 0.;
    float factor_upper = 0.;
    float factor;

    float perc_upper;

    assert(done_callibration);

    inputs_lower = get_entry_bound(true, num_inputs);
    inputs_upper = get_entry_bound(false, num_inputs);

    if (inputs_lower) {
        /* Interpolation of factor between sizes for lower # inputs */
        assert(inputs_lower->done_callibration);
        size_lower = inputs_lower->get_entry_bound(true, transistor_size);
        size_upper = inputs_lower->get_entry_bound(false, transistor_size);

        perc_upper = (transistor_size - size_lower->transistor_size)
                / (size_upper->transistor_size - size_lower->transistor_size);
        factor_lower = perc_upper * size_upper->factor
                + (1 - perc_upper) * size_lower->factor;
    }

    if (inputs_upper) {
        /* Interpolation of factor between sizes for upper # inputs */
        assert(inputs_upper->done_callibration);
        size_lower = inputs_upper->get_entry_bound(true, transistor_size);
        size_upper = inputs_upper->get_entry_bound(false, transistor_size);

        perc_upper = (transistor_size - size_lower->transistor_size)
                / (size_upper->transistor_size - size_lower->transistor_size);
        factor_upper = perc_upper * size_upper->factor
                + (1 - perc_upper) * size_lower->factor;
    }

    if (!inputs_lower) {
        factor = factor_upper;
    } else if (!inputs_upper) {
        factor = factor_lower;
    } else {
        /* Interpolation of factor between inputs */
        perc_upper =
                ((float) (num_inputs - inputs_lower->num_inputs))
                        / ((float) (inputs_upper->num_inputs
                                - inputs_lower->num_inputs));
        factor = perc_upper * factor_upper + (1 - perc_upper) * factor_lower;
    }
    return factor;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void PowerSpicedComponent::sort_me

(

void

)

Definition at line 208 of file PowerSpicedComponent.c.

                                       {
    sort(entries.begin(), entries.end(), sorter_PowerCallibInputs);

    for (vector<PowerCallibInputs*>::iterator it = entries.begin();
            it != entries.end(); it++) {
        (*it)->sort_me();
    }
    sorted = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

float(* PowerSpicedComponent::component_usage)(int num_inputs, float transistor_size)

Definition at line 61 of file PowerSpicedComponent.h.

bool PowerSpicedComponent::done_callibration

Definition at line 64 of file PowerSpicedComponent.h.

std::vector<PowerCallibInputs*> PowerSpicedComponent::entries

Definition at line 58 of file PowerSpicedComponent.h.

bool PowerSpicedComponent::sorted

Definition at line 63 of file PowerSpicedComponent.h.

---

The documentation for this class was generated from the following files:

• PowerSpicedComponent.h
• PowerSpicedComponent.c