torc::placer::Placer Class Reference

Simulated annealing algorithm class. More...

#include <Placer.hpp>

Collaboration diagram for torc::placer::Placer:

Public Member Functions
	Placer (DDB &inDB, PlacerHeuristicBase &inHeuristic)
	~Placer ()
void	generatePlacement (Placement &placement)

Protected Types
typedef architecture::DDB	DDB
typedef boost::uint32_t	uint32

Protected Attributes
DDB &	mDB
PlacerHeuristicBase &	mHeuristic
uint32	mMovesPerTemperature

Detailed Description

Simulated annealing algorithm class.

Definition at line 31 of file placer/Placer.hpp.

Member Typedef Documentation

typedef architecture::DDB torc::placer::Placer::DDB

protected

Definition at line 34 of file placer/Placer.hpp.

typedef boost::uint32_t torc::placer::Placer::uint32

protected

Definition at line 35 of file placer/Placer.hpp.

Constructor & Destructor Documentation

torc::placer::Placer::Placer ( DDB &  inDB, PlacerHeuristicBase &  inHeuristic  )

inline

Definition at line 46 of file placer/Placer.hpp.

: mDB(inDB), mHeuristic(inHeuristic) {}

torc::placer::Placer::~Placer ( )

inline

Definition at line 48 of file placer/Placer.hpp.

{}

Member Function Documentation

void torc::placer::Placer::generatePlacement ( Placement &  placement )

inline

Definition at line 50 of file placer/Placer.hpp.

                                                     {
            //double initialtemperature = 10000;
            placement.updateCostFull(false);
            int currentCost = placement.getCost();
            int newCost = 9999999;
            int goodMoves = 0;
            int movesUndone = 0;
            int acceptedBad = 0;
            int zeroCostMoves = 0;
            int illegalMoves = 0;
            int bestCost = 999999;
            bool done = false;
            double temperature = mHeuristic.getInitialTemperature();
            double acceptrate = 0;
            int doneCount = 0;
            
            boost::timer epochTimer;
            boost::timer totalTimer;
            
            mMovesPerTemperature = mHeuristic.getMovesPerTemperature(); //50000
            //mMovesPerTemperature = 10 * sqrt(pow(placement.getNumInstances(), 3));
            //mMovesPerTemperature = 100000;
            std::cout << "Moves per temperature: " << mMovesPerTemperature << std::endl;
            //placement.updateCostFull(false);
            while (!done) {
                epochTimer.restart();
                //placement.updateCostFull(false);
                goodMoves = 0;
                movesUndone = 0;
                acceptedBad = 0;
                zeroCostMoves = 0;
                illegalMoves = 0;
                std::cout << "currentCost for epoch: " << currentCost;
                
                for (uint32 movei = 0; movei < mMovesPerTemperature; movei++) {
                    if (!placement.randomMove(false)) {
                        //std::cout << "FAILED MOVED" << std::endl;
                        illegalMoves++;
                        continue;
                    }
                    newCost = placement.getCost();
                    if (newCost < bestCost) {
                        bestCost = newCost;
                        //fp.savePlacement();
                    }
                    if (currentCost < newCost) {
                        //if (mRandom.nextDouble() >= 
                        //  Math.exp(((double)currentCost - (double)newCost / temperature))
                        double irand = (double)rand() / (double)(std::numeric_limits<int>::max());
                        if (irand >= exp(((double)currentCost - (double)newCost) / temperature)) {
                            movesUndone++;
                            placement.undoMove(false);
                            //std::cout << " UNDO" << std::endl;
                        } else {
                            acceptedBad++;
                            currentCost = newCost;
                            //std::cout << " ACCEPT BAD" << std::endl;
                        }
                    } else if (currentCost == newCost) {
                        zeroCostMoves++;
                    } else {
                        goodMoves++;
                        currentCost = newCost;
                    }
                }
                
                double epochTime = epochTimer.elapsed();
                //currentCost = newCost;
                acceptrate = (double)acceptedBad / ((double)acceptedBad + (double)movesUndone);
                
                // temperature adjustment
                double tempadjust = 0;
                if (acceptrate > 0.96) {
                    temperature = 0.5 * temperature;
                    tempadjust = (double)0.5;
                } else if (acceptrate <= 0.96 && acceptrate > 0.8) {
                    temperature = 0.9 * temperature;
                    tempadjust = (double)0.9;
                } else if (acceptrate <= 0.8 && acceptrate > 0.15) {
                    temperature = 0.95 * temperature;
                    tempadjust = (double)0.95;
                } else {
                    temperature = 0.8 * temperature;
                    tempadjust = (double)0.8;
                }
                
                // termination condition
                //if (acceptedBad == 0)
                if (goodMoves == 0) {
                    doneCount++;
                } else {
                    doneCount = 0;
                }
                if (doneCount == 10) {
                    done = true;
                }
                
                //%.3f%n
                std::cout << " Good moves: " << goodMoves;
                std::cout << " Accepted bad: " << acceptedBad;
                std::cout << " Undone: " << movesUndone;
                std::cout << " ZeroCostMoves: " << zeroCostMoves;
                std::cout << " Best Cost: " << bestCost;
                std::cout << " Attemped Illegal Moves: " << illegalMoves;
                std::cout << " Acceptance rate: " << acceptrate;
                std::cout << " new temp: " << temperature;
                std::cout << " tempadjust: " << tempadjust;
                //std::cout << " time: " << epochTimer.elapsed();
                std::cout << " time: " << epochTime;
                //std::cout << " | ";
                std::cout << std::endl;
                //fp.getCost(temperature, initialtemperature, true);
            }
            std::cout << "Total time: " << totalTimer.elapsed();
            std::cout << std::endl;
            //fp.displayPlacementWithCost();
            //std::cout << "Here's where we ended:";
            //fp.displayPlacement();
            //((AmorphousFloorPlan)fp).getCostAllPairsDistance(true);
            //fp.restorePlacement();
            //fp.validatePlacement();
            //fp.displayPlacement();
            placement.updateCostFull(false);
            std::cout << "Actual end cost: " << placement.getCost() << std::endl;
        }

Here is the call graph for this function:

Field Documentation

DDB& torc::placer::Placer::mDB

protected

Definition at line 37 of file placer/Placer.hpp.

PlacerHeuristicBase& torc::placer::Placer::mHeuristic

protected

Definition at line 38 of file placer/Placer.hpp.

uint32 torc::placer::Placer::mMovesPerTemperature

protected

Definition at line 39 of file placer/Placer.hpp.

---

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

• placer/Placer.hpp