/**CFile****************************************************************

  FileName    [timDump.c]

  SystemName  [ABC: Logic synthesis and verification system.]

  PackageName [Hierarchy/timing manager.]

  Synopsis    [Saving and loading the hierarchy timing manager.]

  Author      [Alan Mishchenko]
  
  Affiliation [UC Berkeley]

  Date        [Ver. 1.0. Started - April 28, 2007.]

  Revision    [$Id: timDump.c,v 1.00 2007/04/28 00:00:00 alanmi Exp $]

***********************************************************************/

#include "timInt.h"

ABC_NAMESPACE_IMPL_START

////////////////////////////////////////////////////////////////////////
///                        DECLARATIONS                              ///
////////////////////////////////////////////////////////////////////////

#define TIM_DUMP_VER_NUM 1

////////////////////////////////////////////////////////////////////////
///                     FUNCTION DEFINITIONS                         ///
////////////////////////////////////////////////////////////////////////

/**Function*************************************************************

  Synopsis    [Transform the timing manager into the char stream.]

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Vec_Str_t * Tim_ManSave( Tim_Man_t * p, int fHieOnly )
{
    Tim_Box_t * pBox;
    Tim_Obj_t * pObj;
    Vec_Str_t * vStr;
    float * pDelayTable;
    int i, k, TableSize;
    // create output stream
    vStr = Vec_StrAlloc( 10000 );
    // dump version number
    Vec_StrPutI_ne( vStr, TIM_DUMP_VER_NUM );
    // save CI/CO counts
    Vec_StrPutI_ne( vStr, Tim_ManCiNum(p) );
    Vec_StrPutI_ne( vStr, Tim_ManCoNum(p) );
    // save PI/PO counts
    Vec_StrPutI_ne( vStr, Tim_ManPiNum(p) );
    Vec_StrPutI_ne( vStr, Tim_ManPoNum(p) );
    // save number of boxes
    Vec_StrPutI_ne( vStr, Tim_ManBoxNum(p) );
    // for each box, save num_inputs, num_outputs, delay table ID, and copy field
    if ( Tim_ManBoxNum(p) > 0 )
    Tim_ManForEachBox( p, pBox, i )
    {
        Vec_StrPutI_ne( vStr, Tim_ManBoxInputNum(p, pBox->iBox) );
        Vec_StrPutI_ne( vStr, Tim_ManBoxOutputNum(p, pBox->iBox) );
        Vec_StrPutI_ne( vStr, Tim_ManBoxDelayTableId(p, pBox->iBox) ); // can be -1 if delay table is not given
        Vec_StrPutI_ne( vStr, Tim_ManBoxCopy(p, pBox->iBox) );         // can be -1 if the copy is node defined
        //Vec_StrPutI_ne( vStr, Tim_ManBoxIsBlack(p, pBox->iBox) );
    }
    if ( fHieOnly )
        return vStr;
    // save the number of delay tables
    Vec_StrPutI_ne( vStr, Tim_ManDelayTableNum(p) );
    // save the delay tables
    if ( Tim_ManDelayTableNum(p) > 0 )
    Tim_ManForEachTable( p, pDelayTable, i )
    {
        assert( (int)pDelayTable[0] == i );
        // save table ID and dimensions (inputs x outputs)
        Vec_StrPutI_ne( vStr, (int)pDelayTable[0] );
        Vec_StrPutI_ne( vStr, (int)pDelayTable[1] );
        Vec_StrPutI_ne( vStr, (int)pDelayTable[2] );
        // save table contents
        TableSize = (int)pDelayTable[1] * (int)pDelayTable[2];
        for ( k = 0; k < TableSize; k++ )
            Vec_StrPutF( vStr, pDelayTable[k+3] );
    }
    // save PI arrival times
    Tim_ManForEachPi( p, pObj, i )
        Vec_StrPutF( vStr, Tim_ManGetCiArrival(p, pObj->Id) );
    // save PO required times
    Tim_ManForEachPo( p, pObj, i )
        Vec_StrPutF( vStr, Tim_ManGetCoRequired(p, pObj->Id) );
    return vStr;
}

/**Function*************************************************************

  Synopsis    [Restores the timing manager from the char stream.]

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Tim_Man_t * Tim_ManLoad( Vec_Str_t * p, int fHieOnly )
{
    Tim_Man_t * pMan;
    Tim_Obj_t * pObj;
    int VerNum, nCis, nCos, nPis, nPos;
    int nBoxes, nBoxIns, nBoxOuts, CopyBox, fBlack;
    int TableId, nTables, TableSize, TableX, TableY;
    int i, k, curPi, curPo, iStr = 0;
    float * pDelayTable;
    // get version number 
    VerNum = Vec_StrGetI_ne( p, &iStr );
    assert( VerNum == TIM_DUMP_VER_NUM );
    // get the number of CIs/COs
    nCis = Vec_StrGetI_ne( p, &iStr );
    nCos = Vec_StrGetI_ne( p, &iStr );
    // get the number of PIs/POs
    nPis = Vec_StrGetI_ne( p, &iStr );
    nPos = Vec_StrGetI_ne( p, &iStr );
    // start the timing manager
    pMan = Tim_ManStart( nCis, nCos );
    // start boxes
    nBoxes = Vec_StrGetI_ne( p, &iStr );
    assert( pMan->vBoxes == NULL );
    if ( nBoxes > 0 )
        pMan->vBoxes = Vec_PtrAlloc( nBoxes );
    // create boxes
    curPi = nPis;
    curPo = 0;
    for ( i = 0; i < nBoxes; i++ )
    {
        nBoxIns  = Vec_StrGetI_ne( p, &iStr );
        nBoxOuts = Vec_StrGetI_ne( p, &iStr );
        TableId  = Vec_StrGetI_ne( p, &iStr );
        CopyBox  = Vec_StrGetI_ne( p, &iStr );
        fBlack   = 0;//Vec_StrGetI_ne( p, &iStr );
        Tim_ManCreateBox( pMan, curPo, nBoxIns, curPi, nBoxOuts, TableId, fBlack );
        Tim_ManBoxSetCopy( pMan, i, CopyBox );
        curPi += nBoxOuts;
        curPo += nBoxIns;
    }
    curPo += nPos;
    assert( curPi == nCis );
    assert( curPo == nCos );
    if ( fHieOnly )
        return pMan;
    // create delay tables
    nTables = Vec_StrGetI_ne( p, &iStr );
    assert( pMan->vDelayTables == NULL );
    if ( nTables > 0 )
        pMan->vDelayTables = Vec_PtrAlloc( nTables );
    // read delay tables
    for ( i = 0; i < nTables; i++ )
    {
        // read table ID and dimensions
        TableId = Vec_StrGetI_ne( p, &iStr );
        TableX  = Vec_StrGetI_ne( p, &iStr );
        TableY  = Vec_StrGetI_ne( p, &iStr );
        assert( TableId == i );
        // create new table
        TableSize = TableX * TableY;
        pDelayTable = ABC_ALLOC( float, TableSize + 3 );
        pDelayTable[0] = TableId;
        pDelayTable[1] = TableX;
        pDelayTable[2] = TableY;
        // read table contents
        for ( k = 0; k < TableSize; k++ )
            pDelayTable[k+3] = Vec_StrGetF( p, &iStr );
        assert( Vec_PtrSize(pMan->vDelayTables) == TableId );
        Vec_PtrPush( pMan->vDelayTables, pDelayTable );
    }
    assert( Tim_ManDelayTableNum(pMan) == nTables );
    // read PI arrival times
    Tim_ManForEachPi( pMan, pObj, i )
        Tim_ManInitPiArrival( pMan, i, Vec_StrGetF(p, &iStr) );
    // read PO required times
    Tim_ManForEachPo( pMan, pObj, i )
        Tim_ManInitPoRequired( pMan, i, Vec_StrGetF(p, &iStr) );
    assert( Vec_StrSize(p) == iStr );
//    Tim_ManPrint( pMan );
    return pMan;
}

////////////////////////////////////////////////////////////////////////
///                       END OF FILE                                ///
////////////////////////////////////////////////////////////////////////


ABC_NAMESPACE_IMPL_END