// This file is part of the Coriolis Project.
// Copyright (C) Laboratoire LIP6 - Departement ASIM
// Universite Pierre et Marie Curie
//
// Main contributors :
//        Christophe Alexandre   <Christophe.Alexandre@lip6.fr>
//        Sophie Belloeil             <Sophie.Belloeil@lip6.fr>
//        Hugo Clément                   <Hugo.Clement@lip6.fr>
//        Jean-Paul Chaput           <Jean-Paul.Chaput@lip6.fr>
//        Damien Dupuis                 <Damien.Dupuis@lip6.fr>
//        Christian Masson           <Christian.Masson@lip6.fr>
//        Marek Sroka                     <Marek.Sroka@lip6.fr>
// 
// The Coriolis Project  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.
// 
// The Coriolis Project  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  the Coriolis Project;  if  not,  write to the  Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//
// License-Tag
//
// Date   : 29/01/2004
// Author : Christophe Alexandre  <Christophe.Alexandre@lip6.fr>
//
// Authors-Tag 

#include <math.h>
using namespace std;

#include "UpdateSession.h"
USING_NAMESPACE_HURRICANE

#include "CToolBox.h"
using namespace CRL;

#include "Surface.h"
#include "Bin.h"
#include "Row.h"
#include "Mauka.h"
#include "Move.h"
#include "SimAnnealingPlacer.h"

namespace {
    
double ComputeStdDev(double sumcost, double sumsquare, unsigned accepted)
{
    if (accepted <= 1)
	return 0.0;
    
    double stdDev = (sumsquare - sumcost * sumcost / (double)accepted) / ((double)accepted - 1.0);
    if (stdDev > 0.0)
	stdDev = sqrt(stdDev);
    else
	stdDev = 0.0;

    return stdDev;
}

}

namespace MAUKA {
    
SimAnnealingPlacer::SimAnnealingPlacer(Mauka* mauka, double netmult, double binmult, double rowmult)
// *****************************************************************************************************
    : _mauka(mauka)
    , _instanceBins()
    , _netBBoxes()
    , _netCosts()
    , _netFlags()
    , _netCost(0.0)
    , _binCost(0.0)
    , _rowCost(0.0)
    , _initNetCost(0.0)
    , _initBinCost(0.0)
    , _initRowCost(0.0)
    , _netMult(netmult)
    , _binMult(binmult)
    , _rowMult(rowmult)
    , _temperature(0.0)
    , _distance(0.0)
    , _loop(0)
    , _iterationsFactor(0.0)
    , _iterations(0)
    , _moves(0)
    , _sourceEqualTargetMovementNumber(0)
    , _surOccupationTargetMovementNumber(0)
    , _impossibleExchangeMovementNumber(0)
{
    for (unsigned i = 0; i < _mauka->_instanceOccurrencesVector.size(); i++)
    {
        _instanceBins.push_back(NULL);
    }

    for (unsigned netid = 0; netid < _mauka->_nets.size(); netid++)
    {
        vector<Box> bboxes(2);
        _netBBoxes.push_back(bboxes);
        vector<double> costs(2);
        _netCosts.push_back(costs);
        _netFlags.push_back(0);
    }
    
}

void SimAnnealingPlacer::Init()
{
    Surface* surface = _mauka->_surface;
    if (!surface)
        throw Error("Cannot init with no surface ...");
    
    for (unsigned i = 0; i < _mauka->_instanceOccurrencesVector.size(); i++)
    {
        if (_instanceBins[i] == NULL)
            cerr << "no bin for " << _mauka->_instanceOccurrencesVector[i] << endl;
    }
    
    _initNetCost = _netCost = GetNetCost();
    _initBinCost = _binCost = surface->GetBinCost();
    _initRowCost = _rowCost = surface->GetRowCost();

    double   stdDev = 0.0;
    double   sumCost = 0.0;
    double   sumSquare = 0.0;
    unsigned accepted = 0;

    _temperature = 1e30;
    _distance = 1.0;

    if (_mauka->_verbosity.MajorStatsIsOn())
    {
        cout << " o Beginning global placement ...." << endl;
        cout << " o Number of nodes to place is: " << _mauka->_instanceOccurrencesVector.size() << endl;
        cout << " o Margin is: " << 100.0 * surface->GetMargin() << "%" << endl; 
        
        cout << " o Initial RowCost = " << _rowCost << endl;
        cout << " o Initial BinCost = " << _binCost << endl;
        cout << " o Initial NetCost = " << _netCost << endl;
        cout << " o Initial Cost = " << GetCost() << endl;
        cout << " o total bins capa = " << surface->GetBinsCapa() << endl;
        cout << " o total bins size = " << surface->GetBinsSize() << endl;
        cout << " o total subrows capa = " << surface->GetSubRowsCapa() << endl;
        cout << " o Computing Initial Temperature ...";
    }

    Move move(this);

    for (unsigned i = 0; i < _mauka->_instanceOccurrencesVector.size(); i++)
    {
        if (!move.Next(_distance))
        {
            if (_mauka->_verbosity.IsOn())
            {
                cout << " o No More Mouvement Possible ....." << endl;
            }
            return;
        }

        double deltaRowCost = move.GetDeltaRowCost();
        double deltaBinCost = move.GetDeltaBinCost();
        double deltaNetCost = move.GetDeltaNetCost();

        double deltaCost = ComputeCost(deltaRowCost, deltaBinCost, deltaNetCost);
        
        
        if (Accept(deltaCost))
        {
            move.Accept();
            accepted += 1;
            _rowCost += deltaRowCost;
            _netCost += deltaNetCost;
            _binCost += deltaBinCost;
            double cost = GetCost();
            sumCost += cost; sumSquare += cost * cost;
            //sumCost += deltaCost; sumSquare += deltaCost * deltaCost;
        } 
        else
        {
            move.Reject();
        }
        ++_moves;
    }
    
    stdDev = ComputeStdDev(sumCost, sumSquare, accepted);
    _temperature = 20.0 * stdDev;
    _iterationsFactor = 15.0;
    _iterations  = (unsigned)(_iterationsFactor * pow(_mauka->_instanceOccurrencesVector.size(), 1.33));

    if (false)
    {
        double debug = DebugNetCost();
        cout << "debug = " << debug << endl;
        cout << "NetCost = " << _netCost << endl << endl;
        //	assert ((netCost - 1.0 <= debug) && (debug <= netCost + 1.0));
    }

    if (_mauka->_verbosity.IsOn())
    {
        cout << "...... done" << endl;
    }
}


bool SimAnnealingPlacer::Iterate()
{
    unsigned accepted = 0;
    double sumCost = 0.0;
    double sumSquare = 0.0;
    double stdDev = 0.0, sucRatio = 0.0;
    double oldTemperature = 0.0;

    Move move(this);

    for (unsigned i = 0; i < _iterations; ++i)
    {
        if (!move.Next(_distance))
        {
            if (_mauka->_verbosity.IsOn())
            {
                cout << " o No More Mouvement Possible ....." << endl;
            }
            return false;
        }
	    
        double deltaRowCost = move.GetDeltaRowCost();
        double deltaBinCost = move.GetDeltaBinCost();
        double deltaNetCost = move.GetDeltaNetCost();

        double deltaCost = ComputeCost(deltaRowCost, deltaBinCost, deltaNetCost);

#if 0
        cerr << deltaRowCost << endl;
        cerr << deltaBinCost << endl;
        cerr << deltaNetCost << endl;
        cerr << deltaCost << endl << endl; 
#endif

        if (Accept(deltaCost)) {
            move.Accept();

            accepted += 1;
            _rowCost += deltaRowCost;
            _binCost += deltaBinCost;
            _netCost += deltaNetCost;
            double cost = GetCost();
            sumCost += cost; sumSquare += cost * cost;
            //sumCost += deltaCost; sumSquare += deltaCost * deltaCost;
        }
        else
        {
            move.Reject();
        }
        ++_moves;
    }
    ++_loop;
    
    oldTemperature = _temperature;
    stdDev = ComputeStdDev(sumCost, sumSquare, accepted);

    if (stdDev == 0.0)
        _temperature = 0.0;
    else
        _temperature = _temperature * max(0.5, exp(-0.7 * _temperature / stdDev));
    
    sucRatio = accepted / (double)_iterations;
    _distance = max(0.1, min(_distance * (1.0 - 0.44 + sucRatio), 1.0));

    if (_mauka->_verbosity.MajorStatsIsOn())
    {
        cout << "Loop = " << _loop << ", NIns = " << _mauka->_instanceOccurrencesVector.size() 
            << ", Temperature = " << _temperature << ", Cost = " << GetCost() << endl;
        cout << "  RowCost = " << _rowCost << ", BinCost = " <<  _binCost
            << ", NetCost = " << _netCost << endl;
        cout << "  Success Ratio = " << sucRatio * 100.0 << "%, Dist = " << _distance << ", Delta = "
            << _temperature / oldTemperature << endl;
    }
    else if (_mauka->_verbosity.IsOn())
        cerr << ".";

    if (false)
    {
        double debug = DebugNetCost();
        cout << "debug = " << debug << endl;
        cout << "NetCost = " << _netCost << endl << endl;
        //	assert ((netCost - 1.0 <= debug) && (debug <= netCost + 1.0));
    }
    return ((_temperature != 0.0)
            && ((sucRatio > 0.15) || (stdDev > (0.0001 / GetCost()))));
}

double SimAnnealingPlacer::GetNetCost()
// ************************************
{
    double totalNetCost = 0.0;
    for (unsigned netid = 0; netid < _mauka->_netInstances.size(); netid++)
    {
        unsigned lastInstanceId = 0;
        unsigned insCount = 0;
        Box& netBBox = _netBBoxes[netid][_netFlags[netid]];

        double& netCost = _netCosts[netid][_netFlags[netid]];
        netCost = 0.0;
        for (Mauka::UVector::const_iterator uvit = _mauka->_netInstances[netid].begin();
                uvit != _mauka->_netInstances[netid].end();
                uvit++)
        {
            unsigned instanceId = *uvit;
            lastInstanceId = instanceId;
            Bin* bin = _instanceBins[instanceId];
            netBBox.Merge(bin->GetCenter().GetX(), bin->GetCenter().GetY());
            ++insCount;
        }
        if (_mauka->_hasInitX[netid])
            netBBox.Merge(_mauka->_netInitX[netid], netBBox.GetYMin()); 
        if (_mauka->_hasInitY[netid])
            netBBox.Merge(netBBox.GetXMin(), _mauka->_netInitY[netid]); 
        
        if (!insCount)
        {
            if (_mauka->_verbosity.IsOn())
            {
                cout << " o Placer Warning : Net "
                    << _mauka->_nets[netid] << " is not connected..." << endl;
            }
        }
        else
        {
            Unit width = 0;
#if 0
            if (_mauka->_params.takeSplittersIntoAccountOptimization)
            {
                Instance* instance = _instanceOccurrences[lastInstanceId]; 
                Net* net = _nets[netid]; 
                Plug* netPlug = NULL;
                for_each_plug(plug, instance->GetConnectedPlugs())
                {
                    Net* plugNet = plug->GetNet();
                    if (plugNet == net)
                    {
                        netPlug = plug;
                        break;
                    }
                    end_for;
                }
                if (!netPlug)
                    throw Error("Mauka internal error: no plug");
                Hook* bodyHook = netPlug->GetBodyHook();
                for_each_hook(hook, bodyHook->GetHooks())
                {
                    Component* component = hook->GetComponent();
                    if (SplitterContact* splitterContact = dynamic_cast<SplitterContact*>(component))
                    {
                        if (VFence* vfence = dynamic_cast<VFence*>(splitterContact->GetSplitter()->GetFence()))
                        {
                            if (_hasInitX[netid])
                                _hasInitX[netid] = false;
                            else
                            {
                                _hasInitX[netid] = true;
                                _netInitX[netid] = vfence->GetX();
                            }
                        }
                        else if (HFence* hfence = dynamic_cast<HFence*>(splitterContact->GetSplitter()->GetFence()))
                        {
                            if (_hasInitY[netid])
                                _hasInitY[netid] = false;
                            else
                                {
                                    _hasInitY[netid] = true;
                                    _netInitY[netid] = hfence->GetY();
                                }
                        }
                        else throw Error("Mauka internal error");
                    }
                    else if (Pin* pin = dynamic_cast<Pin*>(component))
                    {
                        if (!_mauka->_params.ignorePins)
                        {
                            netBBox.Merge(pin->GetX(), pin->GetY());
                        }
                    }
                    end_for;
                }
                if (_hasInitX[netid])
                    netBBox.Merge(_netInitX[netid], netBBox.GetYMin()); 
                if (_hasInitY[netid])
                    netBBox.Merge(netBBox.GetXMin(), _netInitY[netid]); 
            }
#endif
            width = netBBox.GetWidth();
            if (width == 0)
            {
                //all instances in the same bin...
                //take for width half of the bin
                Bin* bin = _instanceBins[lastInstanceId];
                width = bin->GetWidth() / 2;
            }
            double cost = GetValue(netBBox.GetHeight() + width);
            netCost = cost;
            totalNetCost += cost;
        }
    }
    return totalNetCost;
}

double SimAnnealingPlacer::DebugNetCost()
// **************************************
{
    double totalNetCost = 0.0;
    for (unsigned netid = 0; netid < _mauka->_netInstances.size(); netid++)
    {
        unsigned lastInstanceId = 0;
        unsigned insCount = 0;
        Box box;
        for (Mauka::UVector::const_iterator uvit = _mauka->_netInstances[netid].begin();
                uvit != _mauka->_netInstances[netid].end();
                uvit++)
        {
            unsigned instanceId = *uvit;
            lastInstanceId = instanceId;
            Bin* bin = _instanceBins[instanceId];
            box.Merge(bin->GetCenter().GetX(), bin->GetCenter().GetY());
            ++insCount;
        }
            
        if (insCount)
        {
#if 0
            if (_mauka->_params.takeSplittersIntoAccountOptimization)
            {
                Occurrence instanceOccurrence = _instanceOccurrences[lastInstanceId];
                Instance* instance = dynamic_cast<Instance*>(instanceOccurrence.GetEntity());
                assert(instance);
                Net* net = _nets[netid]; 
                Plug* netPlug = NULL;
                for_each_plug(plug, instance->GetConnectedPlugs())
                {
                    Net* plugNet = plug->GetNet();
                    if (plugNet == net)
                    {
                        netPlug = plug;
                        break;
                    }
                    end_for;
                }
                if (!netPlug)
                    throw Error("Mauka internal error: no plug");
                Hook* bodyHook = netPlug->GetBodyHook();
                bool hasInitX = false;
                bool hasInitY = false;
                Unit netInitX = 0;
                Unit netInitY = 0;
                for_each_hook(hook, bodyHook->GetHooks())
                {
                    if (SplitterContact* splitterContact = dynamic_cast<SplitterContact*>(hook->GetComponent()))
                    {
                        if (VFence* vfence = dynamic_cast<VFence*>(splitterContact->GetSplitter()->GetFence()))
                        {
                            if (hasInitX)
                                hasInitX = false;
                            else
                            {
                                hasInitX = true;
                                netInitX = vfence->GetX();
                            }
                        }
                        else if (HFence* hfence = dynamic_cast<HFence*>(splitterContact->GetSplitter()->GetFence()))
                        {
                            if (hasInitY)
                                hasInitY = false;
                            else
                                {
                                    hasInitY = true;
                                    netInitY = hfence->GetY();
                                }
                        }
                        else throw Error("Mauka internal error");
                    }
                    end_for;
                }
                if (hasInitX)
                    box.Merge(netInitX, box.GetYMin()); 
                if (hasInitY)
                    box.Merge(box.GetXMin(), netInitY); 
            }
#endif
            Unit width = box.GetWidth();
            if (width == 0)
            {
                //all instances in the same bin...
                //take for width half of the bin
                Bin* bin = _instanceBins[lastInstanceId];
                width = bin->GetWidth() / 2;
            }
            totalNetCost += GetValue(box.GetHeight() + width);
        }
    }
    return totalNetCost;
}

void SimAnnealingPlacer::DisplayResults() const
{
   unsigned totalImpossibleMovements =
       _impossibleExchangeMovementNumber
       + _sourceEqualTargetMovementNumber
       + _surOccupationTargetMovementNumber; 
   cout << " o Total impossible movements = " << totalImpossibleMovements << endl;
   cout << " o " << 100.0 * _surOccupationTargetMovementNumber / totalImpossibleMovements 
        << " % suroccupied target" << endl;
   cout << " o " << 100.0 * _sourceEqualTargetMovementNumber / totalImpossibleMovements 
        << " % source equal target" << endl;
   cout << " o " << 100.0 * _impossibleExchangeMovementNumber / totalImpossibleMovements 
        << " % impossible exchange" << endl; 
    
    cout << " o Global Placement finished ....." << endl;
    cout << " o Gain for RowCost      = "
        << 100.0 * (_initRowCost - _rowCost) / _initRowCost << "%" << endl;
    cout << " o Gain for BinCost      = "
        << 100.0 * (_initBinCost - _binCost) / _initBinCost << "%" << endl;
    cout << " o Gain for NetCost      = "
        << 100.0 * (_initNetCost - _netCost) / _initNetCost << "%" << endl;
    cout << " o NetCost Estimated = " << _netCost << endl;
}

double SimAnnealingPlacer::GetCost() const
{
    return ComputeCost(_rowCost, _binCost, _netCost);
}

double SimAnnealingPlacer::ComputeCost(double rowcost, double bincost, double netcost) const
{
    return rowcost  /  _initRowCost * _rowMult
        +  bincost  /  _initBinCost * _binMult
        +  netcost  /  _initNetCost * _netMult;
}

bool SimAnnealingPlacer::Accept(double deltacost) const
{
    if (_mauka->_params.standardSimulatedAnnealing)
    {
        double doubleRand = (double) (rand() / (RAND_MAX + 1.0));
        return ((deltacost <= 0.0)
                || ((_temperature != 0.0)
                    && (exp(-deltacost / _temperature) > doubleRand)));
    }
    else
        return deltacost <= 0.0;
}


void SimAnnealingPlacer::Save() const
{
    OpenUpdateSession();
    for(unsigned i = 0; i < _mauka->_instanceOccurrencesVector.size(); i++)
    {
        Occurrence instanceOccurrence =  _mauka->_instanceOccurrencesVector[i];
        Instance* instance = static_cast<Instance*>(instanceOccurrence.GetEntity());
        Bin* bin = _instanceBins[i];
        bool rowOrientation = bin->GetSubRow()->GetRow()->GetOrientation();
        if (!bin)
            throw Error("No bin for instance");
        Unit xPos = bin->GetCenter().GetX();
        Unit yPos = bin->GetCenter().GetY();
        Box masterABox = instance->GetMasterCell()->GetAbutmentBox();
        Transformation::Orientation orientation;
        if (rowOrientation)
            orientation = Transformation::Orientation::ID;
        else
            orientation = Transformation::Orientation::MY;
        Transformation instanceTransformation = GetTransformation(masterABox
                , xPos - masterABox.GetHalfWidth()
                , yPos - masterABox.GetHalfHeight()
                , orientation);
        instanceOccurrence.GetPath().GetTransformation().Invert().ApplyOn(instanceTransformation);
        instance->SetTransformation(instanceTransformation);
        instance->SetPlacementStatus(Instance::PlacementStatus::PLACED);
        //SetPlacementStatusRecursivelyToPlaced(instance);
    }
    CloseUpdateSession();
}

void SimAnnealingPlacer::Plot(ofstream& out) const
{
    out << "#instances" << endl;
    for (unsigned i = 0; i < _mauka->_instanceOccurrencesVector.size(); i++)
    {
        Instance* instance = static_cast<Instance*>(_mauka->_instanceOccurrencesVector[i].GetEntity());
        const Bin* bin = _instanceBins[i];
        if (!bin)
            throw Error("No bin for instance");
        Unit xPos = bin->GetCenter().GetX();
        Unit yPos = bin->GetCenter().GetY();
        Box masterABox = instance->GetMasterCell()->GetAbutmentBox();
        Box instanceBox = Box(
                xPos - masterABox.GetWidth() / 2,
                yPos - masterABox.GetHeight() / 2,
                xPos + masterABox.GetWidth() / 2,
                yPos + masterABox.GetHeight() / 2);
        out << instanceBox.GetXMin()+0.4 << " " << instanceBox.GetYMin()+0.4 << endl
            << instanceBox.GetXMin()+0.4 << " " << instanceBox.GetYMax()-0.4 << endl
            << instanceBox.GetXMax()-0.4 << " " << instanceBox.GetYMax()-0.4 << endl
            << instanceBox.GetXMax()-0.4 << " " << instanceBox.GetYMin()+0.4 << endl
            << instanceBox.GetXMin()+0.4 << " " << instanceBox.GetYMin()+0.4 << endl << endl;
    }
    out << "EOF" << endl << endl;
    
    out << "#nets" << endl;
    for (unsigned i = 0; i < _mauka->_netInstances.size(); i++)
    {
        if (_mauka->_hasInitX[i])
            continue;
        unsigned nbInstances = 0;
        Unit baryX = 0;
        Unit baryY = 0;
        for (unsigned j = 0; j < _mauka->_netInstances[i].size(); j++)
        {
            unsigned instanceId = _mauka->_netInstances[i][j];
            ++nbInstances;
            const Bin* bin = _instanceBins[instanceId];
            baryX += bin->GetCenter().GetX();
            baryY += bin->GetCenter().GetY();
        }
        
        baryX = baryX / nbInstances;
        baryY = baryY / nbInstances;
        for (unsigned j = 0; j < _mauka->_netInstances[i].size(); j++)
        {
            unsigned instanceId = _mauka->_netInstances[i][j];
            const Bin* bin = _instanceBins[instanceId];
            out << baryX << " " << baryY << endl
                << bin->GetCenter().GetX() << " "
                << bin->GetCenter().GetY() << endl << endl;
        }
    }
    out << "EOF" << endl << endl;

    out << "#nets with fixed point" << endl;
    for (unsigned i = 0; i < _mauka->_netInstances.size(); i++)
    {
        if (!_mauka->_hasInitX[i])
            continue;
        unsigned nbInstances = 1;
        Unit baryX = 0;
        Unit baryY = 0;
        baryX += _mauka->_netInitX[i];
        baryY += _mauka->_netInitY[i];
        for (unsigned j = 0; j < _mauka->_netInstances[i].size(); j++)
        {
            unsigned instanceId = _mauka->_netInstances[i][j];
            ++nbInstances;
            const Bin* bin = _instanceBins[instanceId];
            baryX += bin->GetCenter().GetX();
            baryY += bin->GetCenter().GetY();
        }
        
        baryX = baryX / nbInstances;
        baryY = baryY / nbInstances;
        for (unsigned j = 0; j < _mauka->_netInstances[i].size(); j++)
        {
            unsigned instanceId = _mauka->_netInstances[i][j];
            const Bin* bin = _instanceBins[instanceId];
            out << baryX << " " << baryY << endl
                << bin->GetCenter().GetX() << " "
                << bin->GetCenter().GetY() << endl << endl;
        }
        out << baryX << " " << baryY << endl
            << _mauka->_netInitX[i] << " "
            << _mauka->_netInitY[i] << endl << endl;
    }
    out << "EOF" << endl << endl;
}

}