From: caremoli Date: Thu, 14 Jun 2007 12:12:38 +0000 (+0000) Subject: CCAR: ifdef _DEBUG_ around debug trace X-Git-Tag: BR_For40_DSC_20070622~7 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=7f03ceb136f536cd3f3bde58246cd3044e86fc4f;p=modules%2Fkernel.git CCAR: ifdef _DEBUG_ around debug trace --- diff --git a/src/DSC/DSC_Basic/DSC_Basic.hxx b/src/DSC/DSC_Basic/DSC_Basic.hxx index 0c94e55e6..0efc1a2e2 100755 --- a/src/DSC/DSC_Basic/DSC_Basic.hxx +++ b/src/DSC/DSC_Basic/DSC_Basic.hxx @@ -44,4 +44,5 @@ #define DSC_BASIC_EXPORT #endif -#endif \ No newline at end of file +#endif + diff --git a/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx b/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx index 76888edad..214ccc097 100644 --- a/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx +++ b/src/DSC/DSC_User/Datastream/AdjacentFunctor.hxx @@ -51,23 +51,31 @@ template < typename T > struct AdjacentFunctor { // Suppose que les valeurs passées en paramètres sont triées par ordre croissant bool operator()(const T &v1) { +#ifdef _DEBUG_ std::cout << "AdjacentFunctor: " << _minValue << _maxValue << std::endl; std::cout << "AdjacentFunctor: " << _min << _max << std::endl; +#endif if ( v1 <= _minValue && v1 >= _maxValue) { _equal= true; +#ifdef _DEBUG_ std::cout << "AdjacentFunctor: _equal : " << v1 << std::endl; +#endif return true; } if ( v1 < _minValue ) { _min=v1;_minFound=true; +#ifdef _DEBUG_ std::cout << "AdjacentFunctor: _minFound : " <<_min << std::endl; +#endif } else if ( v1 > _maxValue ) { _max=v1;_maxFound=true; +#ifdef _DEBUG_ std::cout << "AdjacentFunctor: _maxFound : " <<_max << std::endl; +#endif } @@ -94,7 +102,9 @@ template < typename T > struct AdjacentFunctor { bool isEqual() const { return _equal;} bool isBounded() const { return _minFound && _maxFound;} bool getBounds(TNoConst & min, TNoConst & max) const { +#ifdef _DEBUG_ std::cout << "_minFound : " <<_minFound << ", _maxFound " << _maxFound << std::endl; +#endif if (_minFound && _maxFound ) { min=_min; max=_max; return true; } return false; } diff --git a/src/DSC/DSC_User/Datastream/Calcium/Calcium.c b/src/DSC/DSC_User/Datastream/Calcium/Calcium.c index a9732b254..ffcb4801f 100644 --- a/src/DSC/DSC_User/Datastream/Calcium/Calcium.c +++ b/src/DSC/DSC_User/Datastream/Calcium/Calcium.c @@ -150,7 +150,6 @@ InfoType cp_fin (void * component, int code) { fflush(stderr); \ fprintf(stderr,"Beginning of CPExx: %s %d %f\n",nomvar,i,t); \ if ( (data == NULL) || (nbelem < 1) ) return CPNTNULL; \ - printf("cp_name : Valeur de nomvar %s\n",nomvar); \ \ InfoType info = ecp_ecriture_##_typeName (component, mode, &t, i, \ nomvar, nbelem, \ diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx index e64db491f..a6c301ee6 100644 --- a/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumCouplingPolicy.hxx @@ -178,35 +178,51 @@ struct CalciumCouplingPolicy::BoundedDataIdProcessor{ MapIterator it2=it1; ++it2; size_t dataSize1 = DataManipulator::size(it1->second); +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId1 : " << dataSize1 << std::endl; +#endif // Gérer dans calcium la limite de la taille du buffer donnée par // l'utilisateur. size_t dataSize2 = DataManipulator::size(it2->second); +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Taille de donnée dataId2 : " << dataSize2 << std::endl; +#endif size_t dataSize = std::min< size_t >( dataSize1, dataSize2 ); DataId dataId2 = it2->first; DataId dataId1 = it1->first; TimeType t2 = dataId2.first; TimeType t1 = dataId1.first; +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t1 : " << t1 << std::endl; std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t2 : " << t2 << std::endl; +#endif TimeType t = dataId.first; +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de t : " << t << std::endl; +#endif TimeType timeDiff = t2-t1; +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de timeDiff : " << timeDiff << std::endl; +#endif TimeType coeff = (t2-t)/timeDiff; +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Valeur de coeff : " << coeff << std::endl; +#endif InnerType const * const InIt1 = DataManipulator::getPointer(it1->second); +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t1 : " << std::endl; std::copy(InIt1,InIt1+dataSize1,std::ostream_iterator(std::cout," ")); std::cout << std::endl; +#endif InnerType const * const InIt2 = DataManipulator::getPointer(it2->second); +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données à t2 : " << std::endl; std::copy(InIt2,InIt2+dataSize2,std::ostream_iterator(std::cout," ")); std::cout << std::endl; +#endif Type dataOut = DataManipulator::create(dataSize); InnerType * const OutIt = DataManipulator::getPointer(dataOut); @@ -225,9 +241,11 @@ struct CalciumCouplingPolicy::BoundedDataIdProcessor{ // } } +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::BoundedDataIdProcessor : Données calculées à t : " << std::endl; std::copy(OutIt,OutIt+dataSize,std::ostream_iterator(std::cout," ")); std::cout << std::endl; +#endif data = dataOut; } @@ -248,8 +266,10 @@ bool CalciumCouplingPolicy::isDataIdConveniant( AssocContainer & storedDatas, co AdjacentFunctor< key_type > af(expectedDataId); if ( _dependencyType == CalciumTypes::TIME_DEPENDENCY ) { +#ifdef _DEBUG_ std::cout << "-------- time expected : " << expectedDataId.first << std::endl; std::cout << "-------- time expected corrected : " << expectedDataId.first*(1.0-_deltaT) << std::endl; +#endif af.setMaxValue(key_type(expectedDataId.first*(1.0-_deltaT),0)); } isBounded = false; @@ -273,7 +293,9 @@ bool CalciumCouplingPolicy::isDataIdConveniant( AssocContainer & storedDatas, co typename AssocContainer::iterator current = prev; while ( (current != storedDatas.end()) && !af(current->first) ) { +#ifdef _DEBUG_ std::cout << "------- stored time : " << current->first << std::endl; +#endif // if ( af(current->first) ) break; prev = current++; } @@ -290,7 +312,9 @@ bool CalciumCouplingPolicy::isDataIdConveniant( AssocContainer & storedDatas, co else wDataIt1 = storedDatas.end(); +#ifdef _DEBUG_ std::cout << "-------- isDataIdConvenient : isEqual : " << isEqual << " , isBounded " << isBounded << std::endl; +#endif return isEqual || isBounded; } @@ -318,7 +342,9 @@ struct CalciumCouplingPolicy::EraseDataIdProcessor { typedef typename Container::value_type value_type; typedef typename Container::iterator iterator; +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::eraseDataId, storedDatasSize : " << storedDatas.size() << std::endl; +#endif if ( _couplingPolicy._storageLevel == CalciumTypes::UNLIMITED_STORAGE_LEVEL ) return; @@ -327,8 +353,9 @@ struct CalciumCouplingPolicy::EraseDataIdProcessor { if (s > 0 ) { size_t dist=distance(storedDatas.begin(),wDataIt1); for (int i=0; i= expectedDataId iterator it1 = storedDatas.lower_bound(expectedDataId); +#ifdef _DEBUG_ std::cout << "-------- CalciumCouplingPolicy::DisconnectProcessor MARK5 " << std::endl; for (iterator it=storedDatas.begin();it!=storedDatas.end();++it) std::cout <<" "<<(*it).first ; std::cout <(myUsesPort); +#ifdef _DEBUG_ std::cerr << "-------- CalciumInterface(ecp_fin) MARK 1 -|"<< *it <<"|----"<< // typeid(myUsesPort).name() <<"-------------" << typeid(myCalciumUsesPort).name() <<"-------------" << std::endl; +#endif // if ( !myCalciumUsesPort ) // throw Superv_Component_i::BadCast(LOC(OSS()<<"Impossible de convertir le port " @@ -96,10 +98,14 @@ public : myCalciumUsesPort->disconnect(provideLastGivenValue); } catch ( const Superv_Component_i::BadCast & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif throw (CalciumException(CalciumTypes::CPTPVR,ex)); } catch ( const DSC_Exception & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif // Exception venant de SupervComponent : // PortNotDefined(CPNMVR), PortNotConnected(CPLIEN) // ou du port uses : Dsc_Exception @@ -171,26 +177,38 @@ public : CorbaDataType corbaData; long ilong; +#ifdef _DEBUG_ std::cerr << "-------- CalciumInterface(ecp_lecture) MARK 1 ------------------" << std::endl; +#endif if (nomVar.empty()) throw CalciumException(CalciumTypes::CPNMVR, LOC("Le nom de la variable est ")); PortType * port; +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 2 ------------------" << std::endl; +#endif try { port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str()); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 3 ------------------" << std::endl; +#endif } catch ( const Superv_Component_i::PortNotDefined & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif throw (CalciumException(CalciumTypes::CPNMVR,ex)); } catch ( const Superv_Component_i::PortNotConnected & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl;; +#endif throw (CalciumException(CalciumTypes::CPLIEN,ex)); // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN } catch ( const Superv_Component_i::BadCast & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif throw (CalciumException(CalciumTypes::CPTPVR,ex)); } @@ -211,20 +229,30 @@ public : if ( dependencyType == CalciumTypes::TIME_DEPENDENCY ) { corbaData = port->get(ti,tf, 0); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 5 ------------------" << std::endl; +#endif } else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) { corbaData = port->get(0, i); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 6 ------------------" << std::endl; +#endif } else { // Lecture en séquence +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 7 ------------------" << std::endl; +#endif corbaData = port->next(ti,i); } +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 8 ------------------" << std::endl; +#endif size_t corbaDataSize = DataManipulator::size(corbaData); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) corbaDataSize : " << corbaDataSize << std::endl; +#endif // Vérifie si l'utilisateur demande du 0 copie if ( data == NULL ) { @@ -234,10 +262,14 @@ public : nRead = corbaDataSize; // Si les types T et InnerType sont différents, il faudra effectuer tout de même une recopie if (!IsSameType::value) data = new T1[nRead]; +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 9 ------------------" << std::endl; +#endif // On essaye de faire du 0 copy si les types T et InnerType sont les mêmes Copy2UserSpace< IsSameType::value >::apply(data,corbaData,nRead); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 10 ------------------" << std::endl; +#endif // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante : // old : Dans les deux cas la structure CORBA n'est plus utile @@ -247,18 +279,24 @@ public : // DataManipulator::delete_data(corbaData); } else { nRead = std::min < size_t > (corbaDataSize,bufferLength); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 11 ------------------" << std::endl; +#endif Copy2UserSpace::apply(data,corbaData,nRead); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture) MARK 12 ------------------" << std::endl; +#endif // Attention : Seul CalciumCouplingPolicy via eraseDataId doit décider de supprimer ou non // la donnée corba associée à un DataId ! Ne pas effectuer la desallocation suivante : // DataManipulator::delete_data(corbaData); } +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecp_lecture), Valeur de data : " << std::endl; std::copy(data,data+nRead,std::ostream_iterator(std::cout," ")); std::cout << "Ptr :" << data << std::endl; std::cout << "-------- CalciumInterface(ecp_lecture) MARK 13 ------------------" << std::endl; +#endif return; @@ -297,24 +335,36 @@ public : typedef typename DataManipulator::Type CorbaDataType; // Attention != T1 typedef typename DataManipulator::InnerType InnerType; +#ifdef _DEBUG_ std::cerr << "-------- CalciumInterface(ecriture) MARK 1 ------------------" << std::endl; +#endif if ( nomVar.empty() ) throw CalciumException(CalciumTypes::CPNMVR, LOC("Le nom de la variable est ")); PortType * port; +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture) MARK 2 ------------------" << std::endl; +#endif try { port = component.Superv_Component_i::get_port< PortType > (nomVar.c_str()); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture) MARK 3 ------------------" << std::endl; +#endif } catch ( const Superv_Component_i::PortNotDefined & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif throw (CalciumException(CalciumTypes::CPNMVR,ex)); } catch ( const Superv_Component_i::PortNotConnected & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl;; +#endif throw (CalciumException(CalciumTypes::CPLIEN,ex)); // VERIFIER LES CAS DES CODES : CPINARRET, CPSTOPSEQ, CPCTVR, CPLIEN } catch ( const Superv_Component_i::BadCast & ex) { +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif throw (CalciumException(CalciumTypes::CPTPVR,ex)); } @@ -357,7 +407,9 @@ public : LOC(OSS()<<"Le buffer a envoyer est de taille nulle ")); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl; +#endif CorbaDataType corbaData; @@ -388,23 +440,31 @@ public : port->put(*corbaData,t, -1); //Le -1 peut être traité par le cst DataIdContainer et transformé en 0 //Etre obligé de mettre une étoile ds (*corbadata) va poser des pb pour les types <> seq +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture) MARK 5 ------------------" << std::endl; +#endif } else if ( dependencyType == CalciumTypes::ITERATION_DEPENDENCY ) { port->put(*corbaData,-1, i); +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture) MARK 6 ------------------" << std::endl; +#endif } +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture), Valeur de corbaData : " << std::endl; for (int i = 0; i < corbaData->length(); ++i) cout << "-------- CalciumInterface(ecriture), corbaData[" << i << "] = " << (*corbaData)[i] << endl; +#endif // if ( !IsSameType::value ) delete corbaData; // Supprime l'objet CORBA avec eventuellement les données qu'il contient (case de la recopie) delete corbaData; +#ifdef _DEBUG_ std::cout << "-------- CalciumInterface(ecriture) MARK 7 ------------------" << std::endl; +#endif return; } @@ -436,12 +496,20 @@ ecp_fin_ (void * component, int code) { CalciumInterface::ecp_fin( *_component, provideLastGivenValue); } catch ( const CalciumException & ex) { //tester l'arrêt par exception +#ifdef _DEBUG_ std::cerr << ex.what() << std::endl; +#endif return ex.getInfo(); } return CalciumTypes::CPOK; }; +#ifdef _DEBUG_ +#define DEBTRACE(msg) {std::cerr<(dependencyType); \ \ if ( IsSameType< _name , cplx >::value ) _bufferLength*=2; \ - std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" << std::endl; \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1 ------------------" ) \ try { \ CalciumInterface::ecp_lecture< _type, _name >( *_component, \ _dependencyType, \ @@ -466,22 +534,24 @@ ecp_fin_ (void * component, int code) { nomvar, \ _bufferLength, _nRead, *data); \ } catch ( const CalciumException & ex) { \ - std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1b ------------------" << std::endl; \ - std::cerr << ex.what() << std::endl; \ - std::cout << "-------- CalciumInterface(lecture Inter Part) MARK 1ter ------------------" << std::endl; \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1b ------------------" ) \ + DEBTRACE( ex.what() ) \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part) MARK 1ter ------------------" ) \ return ex.getInfo(); \ } \ if ( IsSameType< _name , cplx >::value ) { *nRead=_nRead/2; \ - std::cout << "-------- CalciumInterface(lecture Inter Part) IsSameType cplx -------------" << std::endl; \ - std::cout << "-------- CalciumInterface(lecture Inter Part) _nRead : " << _nRead << std::endl; \ - std::cout << "-------- CalciumInterface(lecture Inter Part) *nRead : " << *nRead << std::endl; \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part) IsSameType cplx -------------" ) \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part) _nRead : " << _nRead ) \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part) *nRead : " << *nRead ) \ } else *nRead = _nRead; \ if (_dependencyType == CalciumTypes::CP_SEQUENTIEL ) \ *ti=(CalTimeType< _type _qual >::TimeType)(_ti); \ - std::cout << "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data << std::endl; \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) \ + /* \ for (int i=0; i<_nRead;++i) \ printf("-------- CalciumInterface(lecture Inter Part), Valeur de data (typage entier) data[%d] : %d \n",i,(*data)[i]); \ - std::cout << "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data << std::endl; \ + */ \ + DEBTRACE( "-------- CalciumInterface(lecture Inter Part), Data Ptr :" << *data ) \ return CalciumTypes::CPOK; \ }; \ extern "C" void ecp_lecture_##_name##_free ( _type _qual * data) { \ @@ -497,23 +567,25 @@ ecp_fin_ (void * component, int code) { double _t=*t; \ size_t _bufferLength=bufferLength; \ if ( IsSameType< _name , cplx >::value ) _bufferLength=_bufferLength*2; \ - std::cout << "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" << std::endl; \ + DEBTRACE( "-------- CalciumInterface(ecriture Inter Part) MARK 1 ------------------" ) \ try { \ - printf("-------- CalciumInterface(ecriture Inter Part), cp_name : Nom de la var. de type %s : %s\n",#_type,nomvar); \ + /*printf("-------- CalciumInterface(ecriture Inter Part), cp_name : Nom de la var. de type %s : %s\n",#_type,nomvar);*/ \ std::string essai(nomvar); \ - std::cout << "----------->-" << nomvar << std::endl; \ + DEBTRACE( "----------->-" << nomvar ) \ CalciumInterface::ecp_ecriture< _type, _name >( *_component, \ static_cast(dependencyType), \ _t,i,nomvar,_bufferLength,*data); \ } catch ( const CalciumException & ex) { \ - std::cerr << ex.what() << std::endl; \ + DEBTRACE( ex.what() ) \ return ex.getInfo(); \ } \ - std::cout << "-------- CalciumInterface(ecriture Inter Part), Valeur de data : " << std::endl; \ - std::cout << "-------- CalciumInterface(ecriture Inter Part), Ptr(1) :" << data << std::endl; \ + DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Valeur de data : " ) \ + DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Ptr(1) :" << data ) \ + /* \ for (int i=0; i<_bufferLength;++i) \ printf("-------- CalciumInterface(ecriture Inter Part), Valeur de data (typage entier) data[%d] : %d \n",i,data[i]); \ - std::cout << "-------- CalciumInterface(ecriture Inter Part), Ptr(2) :" << data << std::endl; \ + */ \ + DEBTRACE( "-------- CalciumInterface(ecriture Inter Part), Ptr(2) :" << data ) \ return CalciumTypes::CPOK; \ }; \ diff --git a/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes2CorbaTypes.cxx b/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes2CorbaTypes.cxx index 0425a6baf..5cf6d10c5 100644 --- a/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes2CorbaTypes.cxx +++ b/src/DSC/DSC_User/Datastream/Calcium/CalciumTypes2CorbaTypes.cxx @@ -48,12 +48,14 @@ table[CalciumTypes::ITERATION_DEPENDENCY ] = Ports::Calcium_Ports::ITERATION_DEP table[CalciumTypes::UNDEFINED_DEPENDENCY ] = Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ; +#ifdef _DEBUG_ std::cout << "CORBA_DEPENDENCY_TYPE() : table["<& ) *this ; +#ifdef _DEBUG_ std::cout << "CORBA_DEPENDENCY_TYPE() : ::operator["< MARK 1 ------------------" << std::endl; +#endif // Crée le type corba à partir du data sans lui en donner la propriété corbaData = DataManipulator::create(nRead,&data,false); +#ifdef _DEBUG_ std::cerr << "-------- Copy2CorbaSpace MARK 2 --(dataPtr : " << DataManipulator::getPointer(corbaData,false)<<")----------------" << std::endl; +#endif } }; @@ -68,11 +72,14 @@ Copy2CorbaSpace { corbaData = DataManipulator::create(nRead); InnerType * dataPtr = DataManipulator::getPointer(corbaData,false); +#ifdef _DEBUG_ std::cerr << "-------- Copy2CorbaSpace MARK 1 --(dataPtr : " << dataPtr<<")----------------" << std::endl; +#endif std::copy(&data,&data+nRead,dataPtr); +#ifdef _DEBUG_ std::cerr << "-------- Copy2CorbaSpace MARK 2 --(nRead: "< MARK 3 : " ; @@ -82,6 +89,7 @@ Copy2CorbaSpace { for (int i=0; i{ // Recopie des données dans le buffer allouée la méthode appelante // dans le cas d'une demande utilisateur 0 copie mais sur // des types utilisateurs et CORBA incompatibles. +#ifdef _DEBUG_ std::cerr << "-------- Copy2UserSpace MARK 1 --(dataPtr : " < MARK 2 --(nRead: "< MARK 3 --(data : " <(std::cout," ")); std::cout << std::endl; +#endif } }; diff --git a/src/DSC/DSC_User/Datastream/Calcium/CorbaTypes2CalciumTypes.cxx b/src/DSC/DSC_User/Datastream/Calcium/CorbaTypes2CalciumTypes.cxx index 1789bcf63..7c827dbb5 100644 --- a/src/DSC/DSC_User/Datastream/Calcium/CorbaTypes2CalciumTypes.cxx +++ b/src/DSC/DSC_User/Datastream/Calcium/CorbaTypes2CalciumTypes.cxx @@ -48,12 +48,14 @@ table[Ports::Calcium_Ports::ITERATION_DEPENDENCY ] = CalciumTypes::ITERATION_DEP table[Ports::Calcium_Ports::UNDEFINED_DEPENDENCY ] = CalciumTypes::UNDEFINED_DEPENDENCY ; +#ifdef _DEBUG_ std::cout << "DEPENDENCY_TYPE() : table["< &table = (map&)*this ; +#ifdef _DEBUG_ std::cout << "DEPENDENCY_TYPE() : ::operator["<(data).get_buffer(true); +#ifdef _DEBUG_ std::cout << "----seq_u_manipulation::get_data(..)-- MARK 2 ------"<< p_data <<"------------" << std::endl; +#endif // Crée une nouvelle sequence propriétaire des données du buffer (pas de recopie) // Les données seront automatiquement désallouées par appel interne à la méthode freebuf diff --git a/src/DSC/DSC_User/Datastream/GenericPort.hxx b/src/DSC/DSC_User/Datastream/GenericPort.hxx index cc9a7e7eb..6148b8f8f 100644 --- a/src/DSC/DSC_User/Datastream/GenericPort.hxx +++ b/src/DSC/DSC_User/Datastream/GenericPort.hxx @@ -120,11 +120,15 @@ GenericPort::close (PortableServer::POA_var po template < typename DataManipulator, typename COUPLING_POLICY> void GenericPort::wakeupWaiting() { +#ifdef _DEBUG_ std::cout << "-------- wakeupWaiting ------------------" << std::endl; +#endif storedDatas_mutex.lock(); if (waitingForAnyDataId || waitingForConvenientDataId) { +#ifdef _DEBUG_ std::cout << "-------- wakeupWaiting:signal --------" << std::endl; std::cout << std::flush; +#endif cond_instance.signal(); } storedDatas_mutex.unlock(); @@ -144,9 +148,11 @@ void GenericPort::put(CorbaInDataType dataPara fflush(stdout); fflush(stderr); try { +#ifdef _DEBUG_ // Affichage des donnees pour DEBUGging cerr << "parametres emis: " << time << ", " << tag << endl; DataManipulator::dump(dataParam); +#endif // L'intérêt des paramètres time et tag pour ce port est décidé dans la politique de couplage // Il est possible de filtrer en prenant en compte uniquement un paramètre time/tag ou les deux @@ -165,9 +171,13 @@ void GenericPort::put(CorbaInDataType dataPara bool expectedDataReceived = false; +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 1 ------------------" << std::endl; +#endif if ( dataIds.empty() ) return; +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 1bis ------------------" << std::endl; +#endif // Recupere les donnees venant de l'ORB et relâche les structures CORBA // qui n'auraient plus cours en sortie de méthode put @@ -176,22 +186,30 @@ void GenericPort::put(CorbaInDataType dataPara int nbOfIter = 0; +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 2 ------ "<< (dataIdIt == dataIds.end()) << "------------" << std::endl; std::cout << "-------- Put : MARK 2bis "<< (*dataIdIt) <<"------------------" << std::endl; +#endif storedDatas_mutex.lock(); for (;dataIdIt != dataIds.end();++dataIdIt) { +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 3 ------------------" << std::endl; +#endif // Duplique l'instance de donnée pour les autres dataIds if (nbOfIter > 0) data = DataManipulator::clone(data); +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 3bis -----"<< dataIdIt.operator*() <<"------------" << std::endl; +#endif DataId currentDataId=*dataIdIt; +#ifdef _DEBUG_ std::cerr << "processing dataId : "<< currentDataId << std::endl; std::cout << "-------- Put : MARK 4 ------------------" << std::endl; +#endif // Ajoute l'instance de la donnee a sa place dans la table de données // ou remplace une instance précédente si elle existe @@ -201,18 +219,24 @@ void GenericPort::put(CorbaInDataType dataPara // <=> premier emplacement où l'on pourrait insérer notre DataId // <=> en général équivaux à (*wDataIt).first >= currentDataId typename DataTable::iterator wDataIt = storedDatas.lower_bound(currentDataId); +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 5 ------------------" << std::endl; +#endif // On n'a pas trouvé de dataId supérieur au notre ou // on a trouvé une clé > à cet Id if (wDataIt == storedDatas.end() || storedDatas.key_comp()(currentDataId,(*wDataIt).first) ) { +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 6 ------------------" << std::endl; +#endif // 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 +#ifdef _DEBUG_ 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; @@ -221,15 +245,19 @@ void GenericPort::put(CorbaInDataType dataPara DataManipulator::delete_data (old_data); } +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 8 ------------------" << std::endl; +#endif // Compte le nombre de dataIds à traiter ++nbOfIter; +#ifdef _DEBUG_ std::cout << "-------- Put : waitingForConvenientDataId : " << waitingForConvenientDataId <<"---" << std::endl; std::cout << "-------- Put : waitingForAnyDataId : " << waitingForAnyDataId <<"---" << std::endl; std::cout << "-------- Put : currentDataId : " << currentDataId <<"---" << std::endl; std::cout << "-------- Put : expectedDataId : " << expectedDataId <<"---" << std::endl; std::cout << "-------- Put : MARK 9 ------------------" << std::endl; +#endif // A simplifier mais : // - pas possible de mettre des arguments optionnels à cause @@ -248,14 +276,18 @@ void GenericPort::put(CorbaInDataType dataPara ( waitingForConvenientDataId && isDataIdConveniant(storedDatas, expectedDataId, dummy1, dummy2, dummy3) ) ) { +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 10 ------------------" << std::endl; +#endif //Doit pouvoir réveiller le get ici (a vérifier) expectedDataReceived = true; } } if (expectedDataReceived) { +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 11 ------------------" << std::endl; +#endif // si waitingForAnyDataId était positionné, c'est forcément lui qui a activer // expectedDataReceived à true if (waitingForAnyDataId) @@ -271,16 +303,22 @@ void GenericPort::put(CorbaInDataType dataPara // Pb2 : également si deux attentes de DataIds même différents car on n'en stocke qu'un ! // Conclusion : Pour l'instant on ne gère pas un service multithreadé qui effectue // des lectures simultanées sur le même port ! +#ifdef _DEBUG_ std::cout << "-------- Put : new datas available ------------------" << std::endl; +#endif fflush(stdout);fflush(stderr); cond_instance.signal(); } +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 12 ------------------" << std::endl; +#endif // Deverouille l'acces a la table : On peut remonter l'appel au dessus de expected... storedDatas_mutex.unlock(); +#ifdef _DEBUG_ std::cout << "-------- Put : MARK 13 ------------------" << std::endl; +#endif fflush(stdout); fflush(stderr); @@ -288,7 +326,6 @@ void GenericPort::put(CorbaInDataType dataPara catch ( const SALOME_Exception & ex ) { // On évite de laisser un mutex storedDatas_mutex.unlock(); - std::cerr << ex; THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR); } @@ -318,9 +355,13 @@ GenericPort::get(TimeType time, bool isEqual, isBounded; typedef typename DataManipulator::InnerType InnerType; +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 1 ------------------" << std::endl; +#endif expectedDataId = DataId(time,tag); +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 2 ------------------" << std::endl; +#endif typename DataTable::iterator wDataIt1; @@ -336,18 +377,23 @@ GenericPort::get(TimeType time, // - l'itérateur wDataIt1 est tel que wDataIt1->first < wdataId < (wDataIt1+1)->first // Méthode provenant de la COUPLING_POLICY isDataIdConveniant(storedDatas,expectedDataId,isEqual,isBounded,wDataIt1); +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 3 ------------------" << std::endl; +#endif // L'ordre des différents tests est important if ( isEqual ) { +#ifdef _DEBUG_ 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; +#ifdef _DEBUG_ 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); @@ -355,17 +401,22 @@ GenericPort::get(TimeType time, 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 processEraseDataId(*this); processEraseDataId.apply(storedDatas,wDataIt1); +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 6 ------------------" << std::endl; +#endif break; } +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 7 ------------------" << std::endl; +#endif //if ( isBounded() && COUPLING_POLICY::template needToProcessBoundedDataId() ) { // Le DataId demandé n'est pas trouvé mais est encadré ET la politique de couplage @@ -379,7 +430,9 @@ GenericPort::get(TimeType time, // l'interpolation. // Les données calciulées sont donc stockées dans storedDatas. // La propriété des données N'EST PAS transférée à l'utilisateur en mode CALCIUM. +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 8 ------------------" << std::endl; +#endif typename COUPLING_POLICY::template BoundedDataIdProcessor processBoundedDataId(*this); //si static BDIP::apply(dataToTransmit,expectedDataId,wDataIt1); @@ -392,6 +445,7 @@ GenericPort::get(TimeType time, // A déplacer en paramètre de la méthode précédente ? storedDatas[expectedDataId]=dataToTransmit; +#ifdef _DEBUG_ 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); @@ -400,6 +454,7 @@ GenericPort::get(TimeType time, std::ostream_iterator< InnerType > (std::cout," ")); std::cout << std::endl; std::cout << "-------- Get : MARK 9 ------------------" << std::endl; +#endif typename COUPLING_POLICY::template EraseDataIdProcessor processEraseDataId(*this); processEraseDataId.apply(storedDatas,wDataIt1); @@ -414,17 +469,23 @@ GenericPort::get(TimeType time, // Réception bloquante sur le dataId demandé // Si l'instance de donnée n'est pas trouvee +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 10 ------------------" << std::endl; +#endif //Positionné à faux dans la méthode put waitingForConvenientDataId = true; +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 11 ------------------" << std::endl; // Ici on attend que la méthode put recoive la donnée std::cout << "-------- Get : waiting datas ------------------" << std::endl; +#endif fflush(stdout);fflush(stderr); cond_instance.wait(); +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 12 ------------------" << std::endl; +#endif } } catch (...) { @@ -435,7 +496,9 @@ GenericPort::get(TimeType time, // Deverouille l'acces a la table storedDatas_mutex.unlock(); +#ifdef _DEBUG_ std::cout << "-------- Get : MARK 13 ------------------" << 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 @@ -472,7 +535,9 @@ GenericPort::next(TimeType &t, try { storedDatas_mutex.lock();// Gérer les Exceptions ds le corps de la méthode +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 1 ---lastDataIdSet ("<::next(TimeType &t, waitingForAnyDataId = false; break; } +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 2 ------------------" << std::endl; +#endif //Positionné à faux dans la méthode put waitingForAnyDataId = true; +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 3 ------------------" << std::endl; // Ici on attend que la méthode put recoive la donnée std::cout << "-------- Next : waiting datas ------------------" << std::endl; +#endif fflush(stdout);fflush(stderr); cond_instance.wait(); if (lastDataIdSet) { +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 4 ------------------" << std::endl; +#endif wDataIt1 = storedDatas.upper_bound(lastDataId); } else { +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 5 ------------------" << std::endl; +#endif lastDataIdSet = true; wDataIt1 = storedDatas.begin(); } } +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 6 ------------------" << std::endl; +#endif t = getTime( (*wDataIt1).first ); tag = getTag ( (*wDataIt1).first ); dataToTransmit = (*wDataIt1).second; +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 7 ------------------" << std::endl; +#endif lastDataId = (*wDataIt1).first; typename COUPLING_POLICY::template EraseDataIdProcessor processEraseDataId(*this); processEraseDataId.apply(storedDatas, wDataIt1); +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 8 ------------------" << std::endl; +#endif } catch (...) { +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 8bis ------------------" << std::endl; +#endif waitingForAnyDataId = false; storedDatas_mutex.unlock(); throw; } storedDatas_mutex.unlock(); +#ifdef _DEBUG_ std::cout << "-------- Next : MARK 9 ------------------" << 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 diff --git a/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx b/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx index 43357dc2e..8d186c509 100644 --- a/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx +++ b/src/DSC/DSC_User/Datastream/GenericUsesPort.hxx @@ -123,11 +123,13 @@ GenericUsesPort< DataManipulator,CorbaPortType, repositoryName, UsesPort >::put CorbaPortTypePtr port = CorbaPortType::_narrow((*_my_ports)[i]); //if (i) { PB1 copyOfData = DataManipulator::clone(data); +#ifdef _DEBUG_ std::cout << "-------- GenericUsesPort::put : Copie de data(" //<< DataManipulator::getPointer(data) <<") vers copyOfData (" <put(*copyOfData,time,tag); // catcher les exceptions @@ -154,7 +156,9 @@ GenericUsesPort< DataManipulator, CorbaPortType, repositoryName, UsesPort { if (_my_ports) delete _my_ports; +#ifdef _DEBUG_ std::cerr << "GenericUsesPort::uses_port_changed" << endl; +#endif _my_ports = new Engines::DSC::uses_port(*new_uses_port); } diff --git a/src/DSC/DSC_User/Superv_Component_i.cxx b/src/DSC/DSC_User/Superv_Component_i.cxx index 2892ddabf..187657c2c 100644 --- a/src/DSC/DSC_User/Superv_Component_i.cxx +++ b/src/DSC/DSC_User/Superv_Component_i.cxx @@ -43,7 +43,9 @@ Superv_Component_i::Superv_Component_i(CORBA::ORB_ptr orb, bool notif) : Engines_DSC_i(orb, poa, contId, instanceName, interfaceName) { +#ifdef _DEBUG_ std::cout << "--Superv_Component_i : MARK 1 ---- " << instanceName << "----" << std::endl; +#endif _my_basic_factory = new basic_port_factory(); _my_palm_factory = new palm_port_factory(); _my_calcium_factory = new calcium_port_factory(); @@ -105,7 +107,9 @@ throw (BadFabType) search_result = the_type.find("CALCIUM_"); if (search_result == 0) { +#ifdef _DEBUG_ std::cout << "---- Superv_Component_i::create_uses_data_port : MARK 1 ---- " << the_type.substr(search_result+8, the_type.length()) << "----" << std::endl; +#endif rtn_proxy = _my_calcium_factory->create_data_proxy(the_type.substr(search_result+8, the_type.length())); } @@ -132,9 +136,13 @@ Superv_Component_i::add_port(const char * port_fab_type, add_port(port, port_name); } else if (s_port_type == "uses") { +#ifdef _DEBUG_ std::cout << "---- Superv_Component_i::add_port : MARK 1 ---- " << std::endl; +#endif uses_port * port = create_uses_data_port(port_fab_type); +#ifdef _DEBUG_ std::cout << "---- Superv_Component_i::add_port : MARK 2 ---- " << std::endl; +#endif add_port(port, port_name); } else diff --git a/src/DSC/DSC_User/Superv_Component_i.hxx b/src/DSC/DSC_User/Superv_Component_i.hxx index 1ee77c610..8b46949ba 100644 --- a/src/DSC/DSC_User/Superv_Component_i.hxx +++ b/src/DSC/DSC_User/Superv_Component_i.hxx @@ -273,7 +273,9 @@ Superv_Component_i::add_port(const char * port_fab_type, assert(port_name); SpecificPortType * retPort; +#ifdef _DEBUG_ std::cout << "---- Superv_Component_i::add_port : Mark 0 ---- " << port_name << "----" << std::endl; +#endif std::string s_port_type(port_type); if (s_port_type == "provides") { @@ -287,10 +289,14 @@ Superv_Component_i::add_port(const char * port_fab_type, else if (s_port_type == "uses") { uses_port * port = create_uses_data_port(port_fab_type); add_port(port, port_name); +#ifdef _DEBUG_ std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- " << port << "----" << std::endl; std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- get_repository_id()" << port->get_repository_id() << std::endl; +#endif retPort = dynamic_cast(port); +#ifdef _DEBUG_ std::cout << "---- Superv_Component_i::add_port : Mark 2 ---- " << retPort << "----" << std::endl; +#endif if ( retPort == NULL ) { delete port; throw BadCast( LOC("La conversion vers le type de port demandé n'est pas possible " )); }