Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 26, 2010, 6:41:19 PM (14 years ago)
Author:
scheusso
Message:

cleaning up function calls a bit in order to buffer calls for not (yet) existing objects

Location:
code/trunk/src/libraries/network/packet
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • code/trunk/src/libraries/network/packet/FunctionCalls.cc

    r6417 r7490  
    3030
    3131#include <cassert>
    32 #include <cstring>
    33 #include "util/MultiType.h"
    34 #include "network/NetworkFunction.h"
     32#include "network/FunctionCall.h"
    3533
    3634namespace orxonox {
    … …  
    4644  flags_ = flags_ | PACKET_FLAGS_FUNCTIONCALLS;
    4745  currentSize_ = 2*sizeof(uint32_t); // for packetid and nrOfCalls
    48   nrOfCalls_ = 0;
    49   currentMemBlocks_ = 1;
    50   data_=new uint8_t[ FUNCTIONCALLS_MEM_ALLOCATION ];
    51   *(Type::Value *)(data_ + _PACKETID ) = Type::FunctionCalls;
    52   *(uint32_t*)(data_+sizeof(uint32_t)) = 0; // set nrOfCalls to 0
    5346}
    5447
    … …  
    6558bool FunctionCalls::process(){
    6659  assert(isDataENetAllocated());
     60 
    6761  uint8_t* temp = data_+sizeof(uint32_t); //skip packetid
    68   this->nrOfCalls_ = *(uint32_t*)temp;
     62  uint32_t nrOfCalls = *(uint32_t*)temp;
    6963  temp += sizeof(uint32_t);
    70   for( unsigned int i = 0; i<this->nrOfCalls_; i++ )
     64  for( unsigned int i = 0; i<nrOfCalls; i++ )
    7165  {
    72     uint32_t functionID = *(uint32_t*)temp;
    73     bool isStatic = *(uint8_t*)(temp+sizeof(uint32_t));
    74     if( isStatic )
    75     {
    76       MultiType mt1, mt2, mt3, mt4, mt5;
    77       NetworkFunctionStatic *fct = NetworkFunctionStatic::getFunction( functionID );
    78       uint32_t nrOfArguments = *(uint32_t*)(temp+sizeof(uint32_t)+sizeof(uint8_t));
    79       temp+=2*sizeof(uint32_t)+sizeof(uint8_t);
    80       switch(nrOfArguments)
    81       {
    82         case 0:
    83           fct->call();
    84           break;
    85         case 1:
    86           mt1.importData(temp);
    87           fct->call(mt1);
    88           break;
    89         case 2:
    90           mt1.importData(temp);
    91           mt2.importData(temp);
    92           fct->call(mt1, mt2);
    93           break;
    94         case 3:
    95           mt1.importData(temp);
    96           mt2.importData(temp);
    97           mt3.importData(temp);
    98           fct->call(mt1, mt2, mt3);
    99           break;
    100         case 4:
    101           mt1.importData(temp);
    102           mt2.importData(temp);
    103           mt3.importData(temp);
    104           mt4.importData(temp);
    105           fct->call(mt1, mt2, mt3, mt4);
    106           break;
    107         case 5:
    108           mt1.importData(temp);
    109           mt2.importData(temp);
    110           mt3.importData(temp);
    111           mt4.importData(temp);
    112           mt5.importData(temp);
    113           fct->call(mt1, mt2, mt3, mt4, mt5);
    114           break;
    115         default:
    116           assert(0);
    117       }
    118     }
    119     else // not a static function, so also handle the objectID
    120     {
    121       MultiType mt1, mt2, mt3, mt4, mt5;
    122       NetworkMemberFunctionBase *fct = NetworkMemberFunctionBase::getFunction( functionID );
    123       uint32_t nrOfArguments = *(uint32_t*)(temp+sizeof(uint32_t)+sizeof(uint8_t));
    124       uint32_t objectID = *(uint32_t*)(temp+2*sizeof(uint32_t)+sizeof(uint8_t));
    125       temp+=3*sizeof(uint32_t)+sizeof(uint8_t);
    126       switch(nrOfArguments)
    127       {
    128         case 0:
    129           fct->call(objectID);
    130           break;
    131         case 1:
    132           mt1.importData(temp);
    133           fct->call(objectID, mt1);
    134           break;
    135         case 2:
    136           mt1.importData(temp);
    137           mt2.importData(temp);
    138           fct->call(objectID, mt1, mt2);
    139           break;
    140         case 3:
    141           mt1.importData(temp);
    142           mt2.importData(temp);
    143           mt3.importData(temp);
    144           fct->call(objectID, mt1, mt2, mt3);
    145           break;
    146         case 4:
    147           mt1.importData(temp);
    148           mt2.importData(temp);
    149           mt3.importData(temp);
    150           mt4.importData(temp);
    151           fct->call(objectID, mt1, mt2, mt3, mt4);
    152           break;
    153         case 5:
    154           mt1.importData(temp);
    155           mt2.importData(temp);
    156           mt3.importData(temp);
    157           mt4.importData(temp);
    158           mt5.importData(temp);
    159           fct->call(objectID, mt1, mt2, mt3, mt4, mt5);
    160           break;
    161         default:
    162           assert(0);
    163           break;
    164       }
    165     }
     66    FunctionCall fctCall;
     67    fctCall.loadData(temp);
     68    fctCall.execute();
    16669  }
     70 
    16771  delete this;
    16872  return true;
    … …  
    17175void FunctionCalls::addCallStatic( uint32_t networkID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    17276  assert(!isDataENetAllocated());
    173 
    174   // first determine the size that has to be reserved for this call
    175   uint32_t callsize = 2*sizeof(uint32_t)+sizeof(uint8_t); //size for network-function-id and nrOfArguments and for bool isStatic
    176   uint32_t nrOfArguments = 0;
    177   if(mt1)
    178   {
    179     nrOfArguments++;
    180     callsize += mt1->getNetworkSize();
    181     if(mt2)
    182     {
    183       nrOfArguments++;
    184       callsize += mt2->getNetworkSize();
    185       if(mt3)
    186       {
    187         nrOfArguments++;
    188         callsize += mt3->getNetworkSize();
    189         if(mt4)
    190         {
    191           nrOfArguments++;
    192           callsize += mt4->getNetworkSize();
    193           if(mt5)
    194           {
    195             nrOfArguments++;
    196             callsize += mt5->getNetworkSize();
    197           }
    198         }
    199       }
    200     }
    201   }
    202 
    203   // now allocated mem if neccessary
    204   if( currentSize_ + callsize > currentMemBlocks_*FUNCTIONCALLS_MEM_ALLOCATION )
    205   {
    206     currentMemBlocks_ = (currentSize_ + callsize)%FUNCTIONCALLS_MEM_ALLOCATION+1;
    207     uint8_t *temp = new uint8_t[currentMemBlocks_*FUNCTIONCALLS_MEM_ALLOCATION];
    208     memcpy( temp, data_, currentSize_ );
    209     delete[] data_;
    210     data_ = temp;
    211   }
    212 
    213   // now serialise the mt values and copy the function id and isStatic
    214   uint8_t* temp = data_+currentSize_;
    215   *(uint32_t*)(data_+sizeof(uint32_t)) = *(uint32_t*)(data_+sizeof(uint32_t))+1; // increase number of calls
    216   *(uint32_t*)temp = networkID;
    217   *(uint8_t*)(temp+sizeof(uint32_t)) = true;
    218   *(uint32_t*)(temp+sizeof(uint32_t)+sizeof(uint8_t)) = nrOfArguments;
    219   temp += 2*sizeof(uint32_t)+sizeof(uint8_t);
    220   if(mt1)
    221   {
    222     mt1->exportData( temp ); //temp gets automatically increased
    223     if(mt2)
    224     {
    225       mt2->exportData( temp ); //temp gets automatically increased
    226       if(mt3)
    227       {
    228         mt3->exportData( temp ); //temp gets automatically increased
    229         if(mt4)
    230         {
    231           mt4->exportData( temp ); //temp gets automatically increased
    232           if(mt5)
    233           {
    234             mt5->exportData( temp ); //temp gets automatically increased
    235           }
    236         }
    237       }
    238     }
    239   }
    240   //currentSize_ += callsize;
    241   currentSize_ = temp-data_;
    242 
     77 
     78  this->functionCalls_.push(orxonox::FunctionCall());
     79  this->functionCalls_.back().setCallStatic( networkID, mt1, mt2, mt3, mt4, mt5 );
     80  this->currentSize_ += this->functionCalls_.back().getSize();
    24381}
    24482
    24583void FunctionCalls::addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    24684  assert(!isDataENetAllocated());
     85 
     86  this->functionCalls_.push(orxonox::FunctionCall());
     87  this->functionCalls_.back().setCallMember( networkID, objectID, mt1, mt2, mt3, mt4, mt5 );
     88  this->currentSize_ += this->functionCalls_.back().getSize();
     89}
    24790
    248   // first determine the size that has to be reserved for this call
    249   uint32_t callsize = 3*sizeof(uint32_t)+sizeof(uint8_t); //size for network-function-id and nrOfArguments and the objectID
    250   uint32_t nrOfArguments = 0;
    251   if(mt1)
     91bool FunctionCalls::send()
     92{
     93  assert(this->functionCalls_.size());
     94  data_=new uint8_t[ currentSize_ ];
     95  *(Type::Value *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
     96  *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls to 0
     97  uint8_t* temp = data_+2*sizeof(uint32_t);
     98 
     99  while( this->functionCalls_.size() )
    252100  {
    253     nrOfArguments++;
    254     callsize += mt1->getNetworkSize();
    255     if(mt2)
    256     {
    257       nrOfArguments++;
    258       callsize += mt2->getNetworkSize();
    259       if(mt3)
    260       {
    261         nrOfArguments++;
    262         callsize += mt3->getNetworkSize();
    263         if(mt4)
    264         {
    265           nrOfArguments++;
    266           callsize += mt4->getNetworkSize();
    267           if(mt5)
    268           {
    269             nrOfArguments++;
    270             callsize += mt5->getNetworkSize();
    271           }
    272         }
    273       }
    274     }
     101    this->functionCalls_.front().saveData( temp );
     102    this->functionCalls_.pop();
    275103  }
     104 
     105  assert( temp==data_+currentSize_ );
     106 
     107  Packet::send();
     108  return true;
     109}
    276110
    277   // now allocated mem if neccessary
    278   if( currentSize_ + callsize > currentMemBlocks_*FUNCTIONCALLS_MEM_ALLOCATION )
    279   {
    280     currentMemBlocks_ = (currentSize_ + callsize)%FUNCTIONCALLS_MEM_ALLOCATION+1;
    281     uint8_t *temp = new uint8_t[currentMemBlocks_*FUNCTIONCALLS_MEM_ALLOCATION];
    282     memcpy( temp, data_, currentSize_ );
    283     delete[] data_;
    284     data_ = temp;
    285   }
    286 
    287   // now serialise the mt values and copy the function id
    288   uint8_t* temp = data_+currentSize_;
    289   *(uint32_t*)(data_+sizeof(uint32_t)) = *(uint32_t*)(data_+sizeof(uint32_t))+1; // increase number of calls
    290   *(uint32_t*)temp = networkID;
    291   *(uint8_t*)(temp+sizeof(uint32_t)) = false;
    292   *(uint32_t*)(temp+sizeof(uint32_t)+sizeof(uint8_t)) = nrOfArguments;
    293   *(uint32_t*)(temp+2*sizeof(uint32_t)+sizeof(uint8_t)) = objectID;
    294   temp += 3*sizeof(uint32_t)+sizeof(uint8_t);
    295   if(mt1)
    296   {
    297     mt1->exportData( temp ); //temp gets automatically increased
    298     if(mt2)
    299     {
    300       mt2->exportData( temp ); //temp gets automatically increased
    301       if(mt3)
    302       {
    303         mt3->exportData( temp ); //temp gets automatically increased
    304         if(mt4)
    305         {
    306           mt4->exportData( temp ); //temp gets automatically increased
    307           if(mt5)
    308           {
    309             mt5->exportData( temp ); //temp gets automatically increased
    310           }
    311         }
    312       }
    313     }
    314   }
    315   currentSize_ += callsize;
    316 
    317 }
    318111
    319112

  • code/trunk/src/libraries/network/packet/FunctionCalls.h

    r6073 r7490  
    3333
    3434#include <cassert>
    35 #include "util/UtilPrereqs.h"
     35#include <queue>
    3636#include "Packet.h"
     37#include "network/FunctionCall.h"
    3738
    3839namespace orxonox {
    … …  
    5758  void addCallStatic( uint32_t networkID, const MultiType* mt1=0, const MultiType* mt2=0, const MultiType* mt3=0, const MultiType* mt4=0, const MultiType* mt5=0);
    5859  void addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1=0, const MultiType* mt2=0, const MultiType* mt3=0, const MultiType* mt4=0, const MultiType* mt5=0);
     60  virtual bool send();
    5961private:
    60   uint32_t nrOfCalls_;
    61   unsigned int clientID_;
    62   uint32_t currentSize_;
    63   uint32_t currentMemBlocks_; // this saves the number of memory blocks (of size FUNCTIONCALLS_MEM_ALLOCATION) allocated
     62  std::queue<orxonox::FunctionCall> functionCalls_;
     63  unsigned int                      clientID_;
     64  uint32_t                          currentSize_;
    6465};
    6566

  • code/trunk/src/libraries/network/packet/Packet.h

    r6073 r7490  
    7676      { clientID_ = id; }
    7777
    78     bool send();
     78    virtual bool send();
    7979  protected:
    8080    Packet();
Note: See TracChangeset for help on using the changeset viewer.