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

File:
1 copied

Legend:

Unmodified
Added
Removed

  • code/trunk/src/libraries/network/FunctionCall.cc

    r7489 r7490  
    2121 *
    2222 *   Author:
    23  *      Oliver Scheuss <scheusso [at] ee.ethz.ch>, (C) 2008
     23 *      Oliver Scheuss <scheusso [at] orxonox.net>, (C) 2010
    2424 *   Co-authors:
    2525 *      ...
    … …  
    2727 */
    2828
    29 #include "FunctionCalls.h"
     29#include "FunctionCall.h"
    3030
    3131#include <cassert>
    32 #include <cstring>
    3332#include "util/MultiType.h"
    34 #include "network/NetworkFunction.h"
     33#include "NetworkFunction.h"
    3534
    3635namespace orxonox {
    37 namespace packet {
    38 
    39 #define   PACKET_FLAGS_FUNCTIONCALLS PacketFlag::Reliable
    40 #define   _PACKETID         0
    41 const unsigned int FUNCTIONCALLS_MEM_ALLOCATION = 1000;
    42 
    43 FunctionCalls::FunctionCalls()
    44  : Packet()
    45 {
    46   flags_ = flags_ | PACKET_FLAGS_FUNCTIONCALLS;
    47   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
    53 }
    54 
    55 FunctionCalls::FunctionCalls( uint8_t* data, unsigned int clientID )
    56   : Packet(data, clientID)
    57 {
    58 }
    59 
    60 FunctionCalls::~FunctionCalls()
    61 {
    62 }
    63 
    64 
    65 bool FunctionCalls::process(){
    66   assert(isDataENetAllocated());
    67   uint8_t* temp = data_+sizeof(uint32_t); //skip packetid
    68   this->nrOfCalls_ = *(uint32_t*)temp;
    69   temp += sizeof(uint32_t);
    70   for( unsigned int i = 0; i<this->nrOfCalls_; i++ )
    71   {
    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     }
    166   }
    167   delete this;
     36
     37FunctionCall::FunctionCall()
     38 : nrOfArguments_(-1), objectID_(OBJECTID_UNKNOWN), size_(0)
     39{
     40}
     41
     42FunctionCall::~FunctionCall()
     43{
     44}
     45
     46
     47bool FunctionCall::execute(){
     48  if( this->bIsStatic_ )
     49  {
     50    NetworkFunctionStatic *fct = NetworkFunctionStatic::getFunction( this->functionID_ );
     51    assert( this->nrOfArguments_==this->arguments_.size() );
     52    switch(this->nrOfArguments_)
     53    {
     54      case 0:
     55        fct->call();
     56        break;
     57      case 1:
     58        fct->call(this->arguments_[0]);
     59        break;
     60      case 2:
     61        fct->call(this->arguments_[0], this->arguments_[1]);
     62        break;
     63      case 3:
     64        fct->call(this->arguments_[0], this->arguments_[1], this->arguments_[2]);
     65        break;
     66      case 4:
     67        fct->call(this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]);
     68        break;
     69      case 5:
     70        fct->call(this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]);
     71        break;
     72      default:
     73        assert(0);
     74    }
     75  }
     76  else // not a static function, so also handle with the objectID
     77  {
     78    NetworkMemberFunctionBase *fct = NetworkMemberFunctionBase::getFunction( this->functionID_ );
     79    switch(this->nrOfArguments_)
     80    {
     81      case 0:
     82        fct->call(this->objectID_);
     83        break;
     84      case 1:
     85        fct->call(this->objectID_, this->arguments_[0]);
     86        break;
     87      case 2:
     88        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1]);
     89        break;
     90      case 3:
     91        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2]);
     92        break;
     93      case 4:
     94        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]);
     95        break;
     96      case 5:
     97        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]);
     98        break;
     99      default:
     100        assert(0);
     101    }
     102  }
    168103  return true;
    169104}
    170105
    171 void FunctionCalls::addCallStatic( uint32_t networkID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    172   assert(!isDataENetAllocated());
     106void FunctionCall::setCallStatic( uint32_t networkID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    173107
    174108  // first determine the size that has to be reserved for this call
    … …  
    179113    nrOfArguments++;
    180114    callsize += mt1->getNetworkSize();
     115    this->arguments_.push_back(*mt1);
    181116    if(mt2)
    182117    {
    183118      nrOfArguments++;
    184119      callsize += mt2->getNetworkSize();
     120      this->arguments_.push_back(*mt2);
    185121      if(mt3)
    186122      {
    187123        nrOfArguments++;
    188124        callsize += mt3->getNetworkSize();
     125        this->arguments_.push_back(*mt3);
    189126        if(mt4)
    190127        {
    191128          nrOfArguments++;
    192129          callsize += mt4->getNetworkSize();
     130          this->arguments_.push_back(*mt4);
    193131          if(mt5)
    194132          {
    195133            nrOfArguments++;
    196134            callsize += mt5->getNetworkSize();
     135            this->arguments_.push_back(*mt5);
    197136          }
    198137        }
    … …  
    200139    }
    201140  }
    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 
    243 }
    244 
    245 void FunctionCalls::addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    246   assert(!isDataENetAllocated());
     141  this->nrOfArguments_ = nrOfArguments;
     142  this->size_ = callsize;
     143  this->bIsStatic_ = true;
     144  this->functionID_ = networkID;
     145}
     146
     147void FunctionCall::setCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    247148
    248149  // 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
     150  uint32_t callsize = 3*sizeof(uint32_t)+sizeof(uint8_t); //size for network-function-id and nrOfArguments and the objectID and bIsStatic
    250151  uint32_t nrOfArguments = 0;
    251152  if(mt1)
    … …  
    253154    nrOfArguments++;
    254155    callsize += mt1->getNetworkSize();
     156    this->arguments_.push_back(*mt1);
    255157    if(mt2)
    256158    {
    257159      nrOfArguments++;
    258160      callsize += mt2->getNetworkSize();
     161      this->arguments_.push_back(*mt2);
    259162      if(mt3)
    260163      {
    261164        nrOfArguments++;
    262165        callsize += mt3->getNetworkSize();
     166        this->arguments_.push_back(*mt3);
    263167        if(mt4)
    264168        {
    265169          nrOfArguments++;
    266170          callsize += mt4->getNetworkSize();
     171          this->arguments_.push_back(*mt4);
    267172          if(mt5)
    268173          {
    269174            nrOfArguments++;
    270175            callsize += mt5->getNetworkSize();
     176            this->arguments_.push_back(*mt5);
    271177          }
    272178        }
    … …  
    274180    }
    275181  }
    276 
    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 }
    318 
    319 
    320 } //namespace packet
     182  this->nrOfArguments_ = nrOfArguments;
     183  this->bIsStatic_ = false;
     184  this->functionID_ = networkID;
     185  this->size_ = callsize;
     186  this->objectID_ = objectID;
     187}
     188
     189void FunctionCall::loadData(uint8_t*& mem)
     190{
     191  this->functionID_ = *(uint32_t*)mem;
     192  this->bIsStatic_ = *(uint8_t*)(mem+sizeof(uint32_t));
     193  this->nrOfArguments_ = *(uint32_t*)(mem+sizeof(uint32_t)+sizeof(uint8_t));
     194  if( this->bIsStatic_ )
     195  {
     196    mem += 2*sizeof(uint32_t)+sizeof(uint8_t);
     197  }
     198  else
     199  {
     200    this->objectID_ = *(uint32_t*)(mem+2*sizeof(uint32_t)+sizeof(uint8_t));
     201    mem += 3*sizeof(uint32_t)+sizeof(uint8_t);
     202  }
     203  for( unsigned int i=0; i<this->nrOfArguments_; ++i )
     204  {
     205    this->arguments_.push_back(MultiType());
     206    this->arguments_.back().importData(mem);
     207  }
     208}
     209
     210void FunctionCall::saveData(uint8_t*& mem)
     211{
     212  // now serialise the mt values and copy the function id and isStatic
     213  *(uint32_t*)mem = this->functionID_;
     214  *(uint8_t*)(mem+sizeof(uint32_t)) = this->bIsStatic_;
     215  *(uint32_t*)(mem+sizeof(uint32_t)+sizeof(uint8_t)) = this->nrOfArguments_;
     216  if( this->bIsStatic_ )
     217  {
     218    mem += 2*sizeof(uint32_t)+sizeof(uint8_t);
     219  }
     220  {
     221    *(uint32_t*)(mem+2*sizeof(uint32_t)+sizeof(uint8_t)) = this->objectID_;
     222    mem += 3*sizeof(uint32_t)+sizeof(uint8_t);
     223  }
     224  for( std::vector<MultiType>::iterator it = this->arguments_.begin(); it!=this->arguments_.end(); ++it )
     225  {
     226    it->exportData( mem );
     227  }
     228}
     229
     230
     231
    321232} //namespace orxonox
Note: See TracChangeset for help on using the changeset viewer.