SimObject.cpp

Go to the documentation of this file.

#include "SimObject.h"
#include "SingleThreadSimEngine.h"
#include "SimNetwork.h"

#include <boost/format.hpp>

#include <string>
using std::string;

#include <cstdlib>

object_type_t SimObject::type = INVALID_OBJECT_TYPE_ID;
SimObjectInformation *SimObject::simObjectInfo = NULL;
// boost::thread_specific_ptr<SingleThreadSimEngine> SimObject::threadSafeEnginePtr(SimObject::noCleanUp);

SimObject::SimObject(engineid_t eid)
{ /* NOOP */ }

SimObject::~SimObject()
{ /* NOOP */ }

SimObject::ID::Packed SimObject::ID::packed() 
{ 
        return *reinterpret_cast<SimObject::ID::Packed*>(this);
}

const SimObject::ID SimObject::ID::Invalid(INVALID_NODE_ID,INVALID_LOCAL_ENGINE_ID,INVALID_OBJECT_TYPE_ID,INVALID_LOCAL_OBJECT_ID);

ostream& operator<<(ostream &s, const SimObject::ID &id)
{
    return s << id.toString();
}

string SimObject::ID::toString(void) const
{
    return str( boost::format("(n=%1%,e=%2%,t=%3%,o=%4%)") % node % eng % type % localid );
}

bool SimObject::ID::operator==(const ID& other) const
{
    return ( this->type == other.type ) &&
           ( this->localid == other.localid ) &&
           ( this->eng == other.eng ) &&
           ( this->node == other.node ) ;
}

bool SimObject::ID::operator!=(const ID& other) const
{
    return ( this->type != other.type ) ||
           ( this->localid != other.localid ) ||
           ( this->eng != other.eng ) ||
           ( this->node != other.node ) ;
}

int SimObject::getFieldOffset(string const & fieldname)
{
    Field const* f = getSimObjectInformation()->getFieldRegistry().findField( fieldname );
    if( f == NULL ) {
        throw(
            PCSIM::Exception(
                "SimObject::getFieldOffset",
                getSimObjectInformation()->name + " has no field named " + fieldname
            ) );
    }    
    return (int)( f->getOffset() );
}

Field const* SimObject::findField(string const & fieldname)
{
    Field const* f = getSimObjectInformation()->getFieldRegistry().findField( fieldname );
    if( f == NULL ) {
        throw(
            PCSIM::Exception(
                "SimObject::findField",
                getSimObjectInformation()->name + " has no field named " + fieldname
            ) );
    }
    return f;
}

void SimObject::setScalarField( Field const*f, double v)
{
        f->setValue( this, v );
}

double SimObject::getScalarField( Field const*f)
{
    return f->getValue( this );
}

//const SingleThreadSimEngine *SimObject::getSimEngine(void)
//{
//    return threadSafeEnginePtr.get();
//}

//void SimObject::setSimEngine( SingleThreadSimEngine *eng )
//{
//    threadSafeEnginePtr.reset( eng );
//}

//const SimNetwork &SimObject::getSimNetwork(void)
//{
//    return threadSafeEnginePtr.get()->network;
//}

/*const Time SimObject::dt(void)
{
    return getSimNetwork().get_dt();
}*/

/*Time const& SimObject::t(void)
{
    return getSimEngine()->getSimulationTime();
}*/

AdvanceInfo::AdvanceInfo( SimNetwork *net, SingleThreadSimEngine *eng ) :
        dt( net->get_dt() ), t( eng->getSimulationTime() ), net( net ), eng( eng )
{
    /* NOOP */
}

SimObject::BlockAllocator SimObject::defaultAllocator;
SimObject::BlockAllocator *SimObject::currentAllocator = &SimObject::defaultAllocator;

SimObject::BlockAllocator::BlockAllocator( size_t blockSize ) :
        blk_sz( blockSize )
{
    mem_block.resize(1);
    free_pos = (char *)malloc( blk_sz );
    mem_block[0] = free_pos;
    num_free_bytes = blk_sz;
}

SimObject::BlockAllocator::~BlockAllocator()
{
    for( size_t i=0; i < mem_block.size(); i++ ) {
        free( mem_block[i] );
    }
}

void *SimObject::BlockAllocator::allocate( size_t size )
{
    void *p;
    if( num_free_bytes < size ) {
        if( size > blk_sz ) {
            free_pos = (char *)malloc( size );
            num_free_bytes = size;
        } else {
            free_pos = (char *)malloc( blk_sz );
            num_free_bytes = blk_sz;
        }
        //printf("--------------------- new block of size %i\n", num_free_bytes);
        mem_block.push_back( free_pos );
    }
    p = free_pos;
    free_pos += size;
    num_free_bytes -= size;
    //printf("- new obj of size %i (%i) at %p\n", size, num_free_bytes, p);
    return p;
}

void SimObject::setAllocator( BlockAllocator & ba )
{
    currentAllocator = &ba;
}

void *SimObject::operator new(size_t sz)
{
    void *p = currentAllocator->allocate(sz);
    currentAllocator = &defaultAllocator;
    return p;
}

void SimObject::operator delete(void *p, size_t size)
{
    //printf("- delete obj of size %i at %p\n", size, p);
    // WE DO NOTHING HERE SINCE THE SimObject::BlockAllocator FREES ANY MEMORY
}

void *SimObject::operator new[](size_t sz)
{
    void *p = currentAllocator->allocate(sz);
    currentAllocator = &defaultAllocator;
    return p;
}

void SimObject::operator delete[](void *, size_t)
{
    // WE DO NOTHING HERE SINCE THE SimObject::BlockAllocator FREES ANY MEMORY
}

---