[Orxonox-commit 130] r2822 - branches/netp/src/network/synchronisable
scheusso at orxonox.net
scheusso at orxonox.net
Mon Mar 23 10:28:26 CET 2009
Author: scheusso
Date: 2009-03-23 09:28:25 +0000 (Mon, 23 Mar 2009)
New Revision: 2822
Modified:
branches/netp/src/network/synchronisable/Synchronisable.cc
branches/netp/src/network/synchronisable/Synchronisable.h
branches/netp/src/network/synchronisable/SynchronisableSpecialisations.cc
branches/netp/src/network/synchronisable/SynchronisableVariable.h
Log:
reduced overhead/load of Synchronisable::getSize quite a lot
Modified: branches/netp/src/network/synchronisable/Synchronisable.cc
===================================================================
--- branches/netp/src/network/synchronisable/Synchronisable.cc 2009-03-23 00:04:52 UTC (rev 2821)
+++ branches/netp/src/network/synchronisable/Synchronisable.cc 2009-03-23 09:28:25 UTC (rev 2822)
@@ -65,7 +65,9 @@
else
objectID=OBJECTID_UNKNOWN;
classID = static_cast<uint32_t>(-1);
-
+
+ // set dataSize to 0
+ this->dataSize_ = 0;
// set standard priority
this->setPriority( priority::normal );
@@ -250,28 +252,32 @@
assert(this->classID==this->getIdentifier()->getNetworkID());
std::list<SynchronisableVariableBase*>::iterator i;
- uint32_t size;
- size=getSize(id, mode);
// start copy header
SynchronisableHeader header(mem);
- header.setDataSize( size );
- header.setObjectID( this->objectID );
- header.setCreatorID( this->creatorID );
- header.setClassID( this->classID );
- header.setDataAvailable( true );
- tempsize += SynchronisableHeader::getSize();
mem += SynchronisableHeader::getSize();
// end copy header
- COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << " length: " << size << std::endl;
+ COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << std::endl;
// copy to location
for(i=syncList.begin(); i!=syncList.end(); ++i){
- (*i)->getData( mem, mode );
- tempsize += (*i)->getSize( mode );
+ tempsize += (*i)->getData( mem, mode );
+ //tempsize += (*i)->getSize( mode );
}
+
+ tempsize += SynchronisableHeader::getSize();
+ header.setObjectID( this->objectID );
+ header.setCreatorID( this->creatorID );
+ header.setClassID( this->classID );
+ header.setDataAvailable( true );
+ header.setDataSize( tempsize );
+
+#ifndef NDEBUG
+ uint32_t size;
+ size=getSize(id, mode);
assert(tempsize==size);
+#endif
return true;
}
@@ -324,12 +330,14 @@
*/
uint32_t Synchronisable::getSize(int32_t id, uint8_t mode){
int tsize=SynchronisableHeader::getSize();
- if(mode==0x0)
+ if (mode==0x0)
mode=state_;
- if(!doSync(id, mode))
+ if (!doSync(id, mode))
return 0;
+ assert( mode==state_ );
+ tsize += this->dataSize_;
std::list<SynchronisableVariableBase*>::iterator i;
- for(i=syncList.begin(); i!=syncList.end(); i++){
+ for(i=stringList.begin(); i!=stringList.end(); ++i){
tsize += (*i)->getSize( mode );
}
return tsize;
Modified: branches/netp/src/network/synchronisable/Synchronisable.h
===================================================================
--- branches/netp/src/network/synchronisable/Synchronisable.h 2009-03-23 00:04:52 UTC (rev 2821)
+++ branches/netp/src/network/synchronisable/Synchronisable.h 2009-03-23 09:28:25 UTC (rev 2822)
@@ -35,6 +35,7 @@
#include <map>
#include <queue>
#include <cassert>
+#include <string>
#include "util/Math.h"
#include "util/mbool.h"
#include "core/OrxonoxClass.h"
@@ -138,7 +139,7 @@
protected:
Synchronisable(BaseObject* creator);
template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
- template <class T> void unregisterVariable(T& var);
+ //template <class T> void unregisterVariable(T& var);
void setObjectMode(uint8_t mode);
void setPriority(unsigned int freq){ objectFrequency_ = freq; }
@@ -155,6 +156,8 @@
uint32_t classID;
std::list<SynchronisableVariableBase*> syncList;
+ std::list<SynchronisableVariableBase*> stringList;
+ uint32_t dataSize_; //size of all variables except strings
static uint8_t state_; // detemines wheter we are server (default) or client
bool backsync_; // if true the variables with mode > 1 will be synchronised to server (client -> server)
unsigned int objectFrequency_;
@@ -163,31 +166,10 @@
static std::queue<uint32_t> deletedObjects_;
};
- template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
- {
- if (bidirectional)
- syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb));
- else
- syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb));
- }
-
- template <class T> void Synchronisable::unregisterVariable(T& var){
- std::list<SynchronisableVariableBase*>::iterator it = syncList.begin();
- while(it!=syncList.end()){
- if( ((*it)->getReference()) == &var ){
- delete (*it);
- syncList.erase(it);
- return;
- }
- else
- it++;
- }
- bool unregistered_nonexistent_variable = false;
- assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:
- // the variable has not been registered before
- }
-
// ================= Specialisation declarations
+
+// template <> _NetworkExport void Synchronisable::registerVariable( const std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
+ template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
template <> _NetworkExport void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
template <> _NetworkExport void Synchronisable::registerVariable( ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
template <> _NetworkExport void Synchronisable::registerVariable( const Vector2& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
@@ -199,6 +181,36 @@
template <> _NetworkExport void Synchronisable::registerVariable( mbool& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
template <> _NetworkExport void Synchronisable::registerVariable( const Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
template <> _NetworkExport void Synchronisable::registerVariable( Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
+
+ template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+ {
+ if (bidirectional)
+ syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb));
+ else
+ syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb));
+ if ( this->state_ == mode )
+ this->dataSize_ += syncList.back()->getSize(state_);
+ }
+
+
+
+// template <class T> void Synchronisable::unregisterVariable(T& var){
+// std::list<SynchronisableVariableBase*>::iterator it = syncList.begin();
+// while(it!=syncList.end()){
+// if( ((*it)->getReference()) == &var ){
+// delete (*it);
+// syncList.erase(it);
+// return;
+// }
+// else
+// it++;
+// }
+// bool unregistered_nonexistent_variable = false;
+// assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:
+// // the variable has not been registered before
+// }
+
+
}
#endif /* _Synchronisable_H__ */
Modified: branches/netp/src/network/synchronisable/SynchronisableSpecialisations.cc
===================================================================
--- branches/netp/src/network/synchronisable/SynchronisableSpecialisations.cc 2009-03-23 00:04:52 UTC (rev 2821)
+++ branches/netp/src/network/synchronisable/SynchronisableSpecialisations.cc 2009-03-23 09:28:25 UTC (rev 2822)
@@ -28,12 +28,31 @@
*/
#include "network/synchronisable/Synchronisable.h"
+#include <string>
// ================ template spezialisation
namespace orxonox{
+// template <> void Synchronisable::registerVariable( const std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+// {
+// if (bidirectional)
+// syncList.push_back(new SynchronisableVariableBidirectional<const std::string>(variable, mode, cb));
+// else
+// syncList.push_back(new SynchronisableVariable<const std::string>(variable, mode, cb));
+// stringList.push_back(syncList.back());
+// }
+
+ template <> void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+ {
+ if (bidirectional)
+ syncList.push_back(new SynchronisableVariableBidirectional<const std::string>(variable, mode, cb));
+ else
+ syncList.push_back(new SynchronisableVariable<const std::string>(variable, mode, cb));
+ stringList.push_back(syncList.back());
+ }
+
template <> void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
{
registerVariable(variable.r, mode, cb, bidirectional);
Modified: branches/netp/src/network/synchronisable/SynchronisableVariable.h
===================================================================
--- branches/netp/src/network/synchronisable/SynchronisableVariable.h 2009-03-23 00:04:52 UTC (rev 2821)
+++ branches/netp/src/network/synchronisable/SynchronisableVariable.h 2009-03-23 09:28:25 UTC (rev 2822)
@@ -55,7 +55,7 @@
class _NetworkExport SynchronisableVariableBase
{
public:
- virtual void getData(uint8_t*& mem, uint8_t mode)=0;
+ virtual uint32_t getData(uint8_t*& mem, uint8_t mode)=0;
virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false)=0;
virtual uint32_t getSize(uint8_t mode)=0;
virtual void* getReference()=0;
@@ -73,7 +73,7 @@
virtual ~SynchronisableVariable();
virtual inline uint8_t getMode(){ return mode_; }
- virtual inline void getData(uint8_t*& mem, uint8_t mode);
+ virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
virtual inline uint32_t getSize(uint8_t mode);
virtual inline void* getReference(){ return (void *)&this->variable_; }
@@ -96,7 +96,7 @@
virtual ~SynchronisableVariableBidirectional();
virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^
- virtual inline void getData(uint8_t*& mem, uint8_t mode);
+ virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
virtual inline uint32_t getSize(uint8_t mode);
private:
@@ -121,10 +121,15 @@
NetworkCallbackManager::deleteCallback(this->callback_); //safe call for deletion
}
- template <class T> inline void SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
+ template <class T> inline uint32_t SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
{
if ( state_ == this->mode_ )
+ {
getAndIncrease( mem );
+ return returnSize();
+ }
+ else
+ return 0;
// mem += SynchronisableVariable<T>::getSize();
}
@@ -229,7 +234,7 @@
{
}
- template <class T> void SynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode)
+ template <class T> uint32_t SynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode)
{
if ( this->mode_ == mode )
{ // we are master for this variable and have to check whether to change the varReference
@@ -245,6 +250,7 @@
// now write the content
SynchronisableVariable<T>::getAndIncrease( mem );
// mem += SynchronisableVariable<T>::getSize();
+ return SynchronisableVariableBidirectional::getSize(mode);
}
template <class T> void SynchronisableVariableBidirectional<T>::putData(uint8_t*& mem, uint8_t mode, bool forceCallback)
More information about the Orxonox-commit
mailing list