std::stringstream msgout,msg;
if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY )
{
- double tt=ti;
- msg << "ti=" << ti << ", tf=" << tf ;
- writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),0,msg.str().c_str());
- corbaData = port->get(tt,tf, 0);
- msgout << "read t=" << tt ;
+ try
+ {
+ double tt=ti;
+ msg << "ti=" << ti << ", tf=" << tf ;
+ writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),0,msg.str().c_str());
+ corbaData = port->get(tt,tf, 0);
+ msgout << "read t=" << tt ;
#ifdef MYDEBUG
- std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl;
#endif
+ }
+ catch ( const DSC_Exception & ex)
+ {
+ writeEvent("END_READ",containerName,componentName,nomVar.c_str(),0,ex.what());
+ throw;
+ }
}
else if ( _dependencyType == CalciumTypes::ITERATION_DEPENDENCY )
{
- msg << "i=" << i ;
- writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),0,msg.str().c_str());
- corbaData = port->get(0, i);
- msgout << "read i=" << i ;
+ try
+ {
+ msg << "i=" << i ;
+ writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),0,msg.str().c_str());
+ corbaData = port->get(0, i);
+ msgout << "read i=" << i ;
#ifdef MYDEBUG
- std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl;
#endif
+ }
+ catch ( const DSC_Exception & ex)
+ {
+ writeEvent("END_READ",containerName,componentName,nomVar.c_str(),0,ex.what());
+ throw;
+ }
}
else
{
// Sequential read
+ try
+ {
#ifdef MYDEBUG
- std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
+ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl;
#endif
- writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),0,"Sequential read");
- corbaData = port->next(ti,i);
- msgout << "read ";
- if(i==0)msgout<< "t=" <<ti;
- else msgout<< "i=" <<i;
+ writeEvent("BEGIN_READ",containerName,componentName,nomVar.c_str(),0,"Sequential read");
+ corbaData = port->next(ti,i);
+ msgout << "read ";
+ if(i==0)msgout<< "t=" <<ti;
+ else msgout<< "i=" <<i;
+ }
+ catch ( const DSC_Exception & ex)
+ {
+ writeEvent("END_READ",containerName,componentName,nomVar.c_str(),0,ex.what());
+ throw;
+ }
}
#ifdef MYDEBUG
#include "CorbaTypeManipulator.hxx"
+#include "Superv_Component_i.hxx"
// SALOME CORBA Exception
#include "Utils_CorbaException.hxx"
// SALOME C++ Exception
#include "Utils_SALOME_Exception.hxx"
+#include "DSC_Exception.hxx"
#include "utilities.h"
#include <iostream>
template < typename DataManipulator, typename COUPLING_POLICY> void
GenericPort<DataManipulator, COUPLING_POLICY>::close (PortableServer::POA_var poa,
- PortableServer::ObjectId_var id) {
+ PortableServer::ObjectId_var id) {
// Ferme le port en supprimant le servant
// La desactivation du servant du POA provoque sa suppression
poa->deactivate_object (id);
template < typename DataManipulator, typename COUPLING_POLICY>
template < typename TimeType,typename TagType>
void GenericPort<DataManipulator, COUPLING_POLICY>::put(CorbaInDataType dataParam,
- TimeType time,
- TagType tag) {
+ TimeType time,
+ TagType tag) {
fflush(stdout);
fflush(stderr);
try {
#endif
// On n'a pas trouvé de dataId supérieur au notre ou
- // on a trouvé une clé > à cet Id
+ // on a trouvé une clé > à cet Id
if (wDataIt == storedDatas.end() || storedDatas.key_comp()(currentDataId,(*wDataIt).first) ) {
#ifdef MYDEBUG
- std::cout << "-------- Put : MARK 6 ------------------" << std::endl;
+ std::cout << "-------- Put : MARK 6 ------------------" << std::endl;
#endif
- // Ajoute la donnee dans la table
- wDataIt = storedDatas.insert(wDataIt, make_pair (currentDataId, data));
+ // Ajoute la donnee dans la table
+ wDataIt = storedDatas.insert(wDataIt, make_pair (currentDataId, data));
} else {
- // Si on n'est pas en fin de liste et qu'il n'y a pas de relation d'ordre strict
- // entre notre dataId et le DataId pointé c'est qu'ils sont identiques
+ // Si on n'est pas en fin de liste et qu'il n'y a pas de relation d'ordre strict
+ // entre notre dataId et le DataId pointé c'est qu'ils sont identiques
#ifdef MYDEBUG
- std::cout << "-------- Put : MARK 7 ------------------" << std::endl;
+ std::cout << "-------- Put : MARK 7 ------------------" << std::endl;
#endif
- // Les données sont remplacées par les nouvelles valeurs
- // lorsque que le dataId existe déjà
- DataType old_data = (*wDataIt).second;
- (*wDataIt).second = data;
- // Detruit la vieille donnee
- DataManipulator::delete_data (old_data);
+ // Les données sont remplacées par les nouvelles valeurs
+ // lorsque que le dataId existe déjà
+ DataType old_data = (*wDataIt).second;
+ (*wDataIt).second = data;
+ // Detruit la vieille donnee
+ DataManipulator::delete_data (old_data);
}
#ifdef MYDEBUG
// sur les dataIds (à cause du lock utilisé dans la méthode put et les méthodes get )
// rem : Utilisation de l'évaluation gauche droite du logical C or
if ( waitingForAnyDataId ||
- ( waitingForConvenientDataId &&
- isDataIdConveniant(storedDatas, expectedDataId, dummy1, dummy2, dummy3) )
- ) {
+ ( waitingForConvenientDataId &&
+ isDataIdConveniant(storedDatas, expectedDataId, dummy1, dummy2, dummy3) )
+ ) {
#ifdef MYDEBUG
- std::cout << "-------- Put : MARK 10 ------------------" << std::endl;
+ std::cout << "-------- Put : MARK 10 ------------------" << std::endl;
#endif
- //Doit pouvoir réveiller le get ici (a vérifier)
- expectedDataReceived = true;
+ //Doit pouvoir réveiller le get ici (a vérifier)
+ expectedDataReceived = true;
}
}
// si waitingForAnyDataId était positionné, c'est forcément lui qui a activer
// expectedDataReceived à true
if (waitingForAnyDataId)
- waitingForAnyDataId = false;
+ waitingForAnyDataId = false;
else
- waitingForConvenientDataId = false;
+ waitingForConvenientDataId = false;
// Reveille le thread du destinataire (stoppe son attente)
// Ne faudrait-il pas réveiller plutôt tous les threads ?
// Celui réveillé ne correspond pas forcément à celui qui demande
template < typename TimeType,typename TagType>
typename DataManipulator::Type
GenericPort<DataManipulator, COUPLING_POLICY>::get(TimeType time,
- TagType tag)
+ TagType tag)
// REM : Laisse passer toutes les exceptions
// En particulier les SALOME_Exceptions qui viennent de la COUPLING_POLICY
// Pour déclarer le throw avec l'exception spécifique il faut que je vérifie
if ( isEqual ) {
#ifdef MYDEBUG
- std::cout << "-------- Get : MARK 4 ------------------" << std::endl;
+ std::cout << "-------- Get : MARK 4 ------------------" << std::endl;
#endif
- // La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM.
- // Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
- // C'est EraseDataId qui choisi ou non de supprimer la donnée
- // Du coup interaction potentielle entre le 0 copy et gestion de l'historique
- dataToTransmit = (*wDataIt1).second;
+ // La propriété de la données N'EST PAS transmise à l'utilisateur en mode CALCIUM.
+ // Si l'utilisateur supprime la donnée, storedDataIds devient incohérent
+ // C'est EraseDataId qui choisi ou non de supprimer la donnée
+ // Du coup interaction potentielle entre le 0 copy et gestion de l'historique
+ dataToTransmit = (*wDataIt1).second;
#ifdef MYDEBUG
- std::cout << "-------- Get : MARK 5 ------------------" << std::endl;
- std::cout << "-------- Get : Données trouvées à t : " << std::endl;
- typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
- size_t N = DataManipulator::size(dataToTransmit);
- std::copy(InIt1, InIt1 + N,
- std::ostream_iterator< InnerType > (std::cout," "));
- std::cout << std::endl;
+ std::cout << "-------- Get : MARK 5 ------------------" << std::endl;
+ std::cout << "-------- Get : Données trouvées à t : " << std::endl;
+ typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
+ size_t N = DataManipulator::size(dataToTransmit);
+ std::copy(InIt1, InIt1 + N,
+ std::ostream_iterator< InnerType > (std::cout," "));
+ std::cout << std::endl;
#endif
- // Décide de la suppression de certaines instances de données
- // La donnée contenu dans la structure CORBA et son dataId sont désallouées
- // Méthode provenant de la COUPLING_POLICY
- typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
- processEraseDataId.apply(storedDatas,wDataIt1);
+ // Décide de la suppression de certaines instances de données
+ // La donnée contenu dans la structure CORBA et son dataId sont désallouées
+ // Méthode provenant de la COUPLING_POLICY
+ typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas,wDataIt1);
#ifdef MYDEBUG
- std::cout << "-------- Get : MARK 6 ------------------" << std::endl;
+ std::cout << "-------- Get : MARK 6 ------------------" << std::endl;
#endif
- break;
+ break;
}
#ifdef MYDEBUG
// Le DataId demandé n'est pas trouvé mais est encadré ET la politique de couplage
// implémente une méthode processBoundedDataId capable de générer les données à retourner
if ( isBounded ) {
- // Pour être cohérent avec la politique du bloc précédent
- // on stocke la paire (dataId,données interpolées ).
- // CALCIUM ne stockait pas les données interpolées.
- // Cependant comme les données sont censées être produites
- // par ordre croissant de DataId, de nouvelles données ne devrait pas améliorer
- // l'interpolation.
-#ifdef MYDEBUG
- std::cout << "-------- Get : MARK 8 ------------------" << std::endl;
-#endif
-
- typedef typename COUPLING_POLICY::template BoundedDataIdProcessor<DataManipulator> BDI;
- BDI processBoundedDataId(*this);
- // typename COUPLING_POLICY::template BoundedDataIdProcessor<DataManipulator> processBoundedDataId(*this);
- //si static BDIP::apply(dataToTransmit,expectedDataId,wDataIt1);
- //ancienne version template processBoundedDataId<DataManipulator>(dataToTransmit,expectedDataId,wDataIt1);
- //BDIP processBoundedDataId;
- processBoundedDataId.apply(dataToTransmit,expectedDataId,wDataIt1);
+ // Pour être cohérent avec la politique du bloc précédent
+ // on stocke la paire (dataId,données interpolées ).
+ // CALCIUM ne stockait pas les données interpolées.
+ // Cependant comme les données sont censées être produites
+ // par ordre croissant de DataId, de nouvelles données ne devrait pas améliorer
+ // l'interpolation.
+#ifdef MYDEBUG
+ std::cout << "-------- Get : MARK 8 ------------------" << std::endl;
+#endif
+
+ typedef typename COUPLING_POLICY::template BoundedDataIdProcessor<DataManipulator> BDI;
+ BDI processBoundedDataId(*this);
+ // typename COUPLING_POLICY::template BoundedDataIdProcessor<DataManipulator> processBoundedDataId(*this);
+ //si static BDIP::apply(dataToTransmit,expectedDataId,wDataIt1);
+ //ancienne version template processBoundedDataId<DataManipulator>(dataToTransmit,expectedDataId,wDataIt1);
+ //BDIP processBoundedDataId;
+ processBoundedDataId.apply(dataToTransmit,expectedDataId,wDataIt1);
- // Il ne peut pas y avoir déjà une clé expectedDataId dans storedDatas (utilisation de la notation [] )
- // La nouvelle donnée produite est stockée, ce n'était pas le cas dans CALCIUM
- // Cette opération n'a peut être pas un caractère générique.
- // A déplacer en paramètre de la méthode précédente ? ou déléguer ce choix au mode de couplage ?
- storedDatas[expectedDataId]=dataToTransmit;
+ // Il ne peut pas y avoir déjà une clé expectedDataId dans storedDatas (utilisation de la notation [] )
+ // La nouvelle donnée produite est stockée, ce n'était pas le cas dans CALCIUM
+ // Cette opération n'a peut être pas un caractère générique.
+ // A déplacer en paramètre de la méthode précédente ? ou déléguer ce choix au mode de couplage ?
+ storedDatas[expectedDataId]=dataToTransmit;
#ifdef MYDEBUG
- std::cout << "-------- Get : Données calculées à t : " << std::endl;
- typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
- size_t N = DataManipulator::size(dataToTransmit);
+ std::cout << "-------- Get : Données calculées à t : " << std::endl;
+ typename DataManipulator::InnerType const * const InIt1 = DataManipulator::getPointer(dataToTransmit);
+ size_t N = DataManipulator::size(dataToTransmit);
- std::copy(InIt1, InIt1 + N,
- std::ostream_iterator< InnerType > (std::cout," "));
- std::cout << std::endl;
- std::cout << "-------- Get : MARK 9 ------------------" << std::endl;
+ std::copy(InIt1, InIt1 + N,
+ std::ostream_iterator< InnerType > (std::cout," "));
+ std::cout << std::endl;
+ std::cout << "-------- Get : MARK 9 ------------------" << std::endl;
#endif
- typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
- processEraseDataId.apply(storedDatas,wDataIt1);
+ typename COUPLING_POLICY::template EraseDataIdProcessor<DataManipulator> processEraseDataId(*this);
+ processEraseDataId.apply(storedDatas,wDataIt1);
- break;
+ break;
}
// Délègue au mode de couplage la gestion d'une demande de donnée non disponible
std::cout << "-------- Get : waiting datas ------------------" << std::endl;
#endif
fflush(stdout);fflush(stderr);
- cond_instance.wait();
+ unsigned long ts, tns,rs=Superv_Component_i::dscTimeOut;
+ if(rs==0)
+ cond_instance.wait();
+ else
+ {
+ //Timed wait on omni condition
+ omni_thread::get_time(&ts,&tns, rs,0);
+ int success=cond_instance.timedwait(ts,tns);
+ if(!success)
+ {
+ // Waiting too long probably blocking
+ std::stringstream msg;
+ msg<<"Timeout ("<<rs<<" s) exceeded";
+ throw DSC_Exception(msg.str());
+ }
+ }
+
#ifdef MYDEBUG
std::cout << "-------- Get : MARK 12 ------------------" << std::endl;
template < typename TimeType,typename TagType>
typename DataManipulator::Type
GenericPort<DataManipulator, COUPLING_POLICY>::get(TimeType& ti,
- TimeType tf,
- TagType tag ) {
+ TimeType tf,
+ TagType tag ) {
ti = COUPLING_POLICY::getEffectiveTime(ti,tf);
return get(ti,tag);
}
template < typename TimeType,typename TagType>
typename DataManipulator::Type
GenericPort<DataManipulator, COUPLING_POLICY>::next(TimeType &t,
- TagType &tag ) {
+ TagType &tag ) {
typedef typename COUPLING_POLICY::DataId DataId;
// Délègue au mode de couplage la gestion d'une demande de donnée non disponible
// si le port est deconnecté
if ( processDisconnect.apply(storedDatas, lastDataId, wDataIt1) ) {
- waitingForAnyDataId = false; break;
+ waitingForAnyDataId = false; break;
}
#ifdef MYDEBUG
std::cout << "-------- Next : waiting datas ------------------" << std::endl;
#endif
fflush(stdout);fflush(stderr);
- cond_instance.wait();
+ unsigned long ts, tns,rs=Superv_Component_i::dscTimeOut;
+ if(rs==0)
+ cond_instance.wait();
+ else
+ {
+ //Timed wait on omni condition
+ omni_thread::get_time(&ts,&tns, rs,0);
+ int success=cond_instance.timedwait(ts,tns);
+ if(!success)
+ {
+ // Waiting too long probably blocking
+ std::stringstream msg;
+ msg<<"Timeout ("<<rs<<" s) exceeded";
+ throw DSC_Exception(msg.str());
+ }
+ }
if (lastDataIdSet) {
#ifdef MYDEBUG
- std::cout << "-------- Next : MARK 4 ------------------" << std::endl;
+ std::cout << "-------- Next : MARK 4 ------------------" << std::endl;
#endif
- wDataIt1 = storedDatas.upper_bound(lastDataId);
+ wDataIt1 = storedDatas.upper_bound(lastDataId);
} else {
#ifdef MYDEBUG
- std::cout << "-------- Next : MARK 5 ------------------" << std::endl;
+ std::cout << "-------- Next : MARK 5 ------------------" << std::endl;
#endif
- lastDataIdSet = true;
- wDataIt1 = storedDatas.begin();
+ lastDataIdSet = true;
+ wDataIt1 = storedDatas.begin();
}
}
