Changeset 20197

Show
Ignore:
Timestamp:
05/10/07 10:04:47 (2 years ago)
Author:
aronb
Message:

Change how we handle packet data so that we don't copy it around nearly as much.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • juggler/trunk/modules/gadgeteer/cluster/Packets/ConfigPacket.cpp

    r20118 r20197  
    7979} 
    8080 
    81 void ConfigPacket::parse(vpr::BufferObjectReader* reader) 
     81void ConfigPacket::parse() 
    8282{ 
    83    mConfig = reader->readString(); 
    84    mType = reader->readUint16(); 
     83   mPacketReader->setCurPos(0); 
     84 
     85   mConfig = mPacketReader->readString(); 
     86   mType = mPacketReader->readUint16(); 
    8587} 
    8688 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/ConfigPacket.h

    r20118 r20197  
    8585    * Parses the data stream into the local member variables. 
    8686    */ 
    87    virtual void parse(vpr::BufferObjectReader* reader); 
     87   virtual void parse(); 
    8888 
    8989   /** 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/DataPacket.cpp

    r20118 r20197  
    4343DataPacket::DataPacket() 
    4444   : Packet(vpr::GUID()) 
    45    , mDeviceData(NULL) 
    4645{;} 
    4746 
    48 DataPacket::DataPacket(const vpr::GUID& pluginId, const vpr::GUID& objectId, std::vector<vpr::Uint8>* data) 
     47DataPacket::DataPacket(const vpr::GUID& pluginId, const vpr::GUID& objectId) 
    4948   : Packet(pluginId) 
    5049   , mObjectId(objectId) 
    51    , mDeviceData(data) 
    5250{       
    5351   // Create a Header for this packet with the correect type and size. 
    …… 
    5755                        + 16 /*Plugin GUID*/ 
    5856                        + 16 /*Object GUID*/ 
    59                         + mDeviceData->size(), 
     57                        + 0 /* Empty now, but needs updated later. */, 
    6058                        0/*Field not curently used*/); 
    6159   // Serialize the given data. 
    62    serialize(); 
     60   //serialize(); 
    6361} 
    6462 
    …… 
    6866} 
    6967 
    70 DataPacketPtr DataPacket::create(const vpr::GUID& pluginId, const vpr::GUID& objectId, 
    71                                  std::vector<vpr::Uint8>* data) 
     68DataPacketPtr DataPacket::create(const vpr::GUID& pluginId, const vpr::GUID& objectId) 
    7269{ 
    73    return DataPacketPtr(new DataPacket(pluginId, objectId, data)); 
     70   return DataPacketPtr(new DataPacket(pluginId, objectId)); 
    7471} 
    7572    
    7673DataPacket::~DataPacket() 
    7774{ 
    78    delete mDeviceData; 
    7975} 
    8076 
    81 void DataPacket::serialize() 
     77void DataPacket::serialize(vpr::SerializableObject& object) 
    8278{ 
    8379   // Clear the data stream. 
    …… 
    9389   // Serialize device GUID. 
    9490   mObjectId.writeObject(mPacketWriter); 
    95     
    96    // mDeviceData is a pointer that points at the DeviceData located in the DeviceServer 
    97    // this data will be updated every frame before sent. 
     91 
     92   object.writeObject(mPacketWriter); 
    9893} 
    9994 
    100 void DataPacket::parse(vpr::BufferObjectReader* reader) 
     95void DataPacket::parse() 
    10196{ 
    102    // De-Serialize plugin GUID 
    103    mPluginId.readObject(reader); 
     97   mPacketReader->setCurPos(0); 
    10498 
    10599   // De-Serialize plugin GUID 
    106    mObjectId.readObject(reader); 
    107           
    108    mDeviceData = new std::vector<vpr::Uint8>(); 
     100   mPluginId.readObject(mPacketReader); 
    109101 
    110    unsigned int data_size = mHeader->getPacketLength() - Header::RIM_PACKET_HEAD_SIZE - 32; 
    111    for(unsigned int i = 0 ; i < data_size ; i++) 
    112    { 
    113       mDeviceData->push_back(*(reader->readRaw(1))); 
    114    } 
     102   // De-Serialize plugin GUID 
     103   mObjectId.readObject(mPacketReader); 
     104 
     105   // There is extra data on the buffer for the object itself. 
    115106} 
    116107 
    …… 
    122113   boost::ignore_unused_variable_warning(debug_level); 
    123114    
    124    /* 
    125115   vprDEBUG_BEGIN(gadgetDBG_RIM,debug_level)  
    126116      <<  clrOutBOLD(clrYELLOW,"==== Device Data Packet ====\n") << vprDEBUG_FLUSH; 
    …… 
    137127   vprDEBUG_END(gadgetDBG_RIM,debug_level)  
    138128      <<  clrOutBOLD(clrYELLOW,"============================\n") << vprDEBUG_FLUSH; 
    139    */ 
    140129} 
    141130 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/DataPacket.h

    r20118 r20197  
    6161    *                  the network 
    6262    */ 
    63    DataPacket(const vpr::GUID& pluginId, const vpr::GUID& objectId, 
    64               std::vector<vpr::Uint8>* data); 
     63   DataPacket(const vpr::GUID& pluginId, const vpr::GUID& objectId); 
    6564 
    6665public: 
    …… 
    7978    * @since 1.3.7 
    8079    */ 
    81    static DataPacketPtr create(const vpr::GUID& pluginId, const vpr::GUID& objectId, 
    82                                std::vector<vpr::Uint8>* data); 
     80   static DataPacketPtr create(const vpr::GUID& pluginId, const vpr::GUID& objectId); 
    8381 
    8482   /** 
    …… 
    9088    * Serializes member variables into a data stream. 
    9189    */ 
    92    void serialize(); 
     90   void serialize(vpr::SerializableObject& object); 
    9391 
    9492   /** 
    9593    * Parses the data stream into the local member variables. 
    9694    */ 
    97    virtual void parse(vpr::BufferObjectReader* reader); 
     95   virtual void parse(); 
    9896 
    9997   /** 
    …… 
    118116   } 
    119117 
    120    /** 
    121     * Return a pointer to the raw data that we are sending across the network 
    122     */ 
    123    std::vector<vpr::Uint8>* getDeviceData() 
    124    { 
    125       return mDeviceData; 
    126    } 
    127  
    128118private: 
    129119   vpr::GUID                  mObjectId;     /**< GUID of the object that we are sending raw data for. */ 
    130    std::vector<vpr::Uint8>*   mDeviceData;   /**< Raw data that we are sending across the network. */ 
    131120}; 
    132121 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/DeviceAck.cpp

    r20118 r20197  
    113113} 
    114114 
    115 void DeviceAck::parse(vpr::BufferObjectReader* reader) 
     115void DeviceAck::parse() 
    116116{ 
     117   mPacketReader->setCurPos(0); 
     118 
    117119   // De-Serialize plugin GUID 
    118    mPluginId.readObject(reader); 
     120   mPluginId.readObject(mPacketReader); 
    119121 
    120122   // De-Serialize Device GUID 
    121    mId.readObject(reader); 
     123   mId.readObject(mPacketReader); 
    122124       
    123125   // De-Serialize the Device Name 
    124    mDeviceName = reader->readString(); 
     126   mDeviceName = mPacketReader->readString(); 
    125127 
    126128   // De-Serialize the Base Type of the acknowledged device 
    127    mDeviceBaseType = reader->readString(); 
     129   mDeviceBaseType = mPacketReader->readString(); 
    128130 
    129131   // De-Serialize the hostname of the acknowledging node 
    130    mHostname = reader->readString(); 
     132   mHostname = mPacketReader->readString(); 
    131133 
    132134   // De-Serialize the Ack boolean 
    133    mAck = reader->readBool(); 
     135   mAck = mPacketReader->readBool(); 
    134136} 
    135137 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/DeviceAck.h

    r20118 r20197  
    9696    * Parses the data stream into the local member variables. 
    9797    */ 
    98    virtual void parse(vpr::BufferObjectReader* reader); 
     98   virtual void parse(); 
    9999 
    100100   /** 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/EndBlock.cpp

    r20118 r20197  
    9393 * Parses the data stream into the local member variables. 
    9494 */ 
    95 void EndBlock::parse(vpr::BufferObjectReader* reader) 
     95void EndBlock::parse() 
    9696{ 
     97   mPacketReader->setCurPos(0); 
     98 
    9799   // De-Serialize the Temp Var 
    98    mTempVar = reader->readUint16(); 
     100   mTempVar = mPacketReader->readUint16(); 
    99101} 
    100102 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/EndBlock.h

    r20118 r20197  
    8484    * Parses the data stream into the local member variables. 
    8585    */ 
    86    virtual void parse(vpr::BufferObjectReader* reader); 
     86   virtual void parse(); 
    8787 
    8888   /** 

  • juggler/trunk/modules/gadgeteer/cluster/Packets/Packet.h

    r20118 r20197  
    8686    * Return the vpr::PacketReader object used to retrieve data from the packet. 
    8787    */ 
    88    vpr::ObjectReader* getPacketReader() 
     88   vpr::BufferObjectReader* getPacketReader() 
    8989   { 
    9090      return mPacketReader; 
     91   } 
     92 
     93   /** 
     94    * Return the vpr::PacketReader object used to retrieve data from the packet. 
     95    */ 
     96   vpr::BufferObjectWriter* getPacketWriter() 
     97   { 
     98      return mPacketWriter; 
    9199   } 
    92100 
    …… 
    120128   } 
    121129 
    122    virtual void parse(vpr::BufferObjectReader* reader) = 0; 
     130   virtual void parse() = 0; 
    123131protected: 
    124132   Header* mHeader;                          /**< Header used to specify the type/size of this packet.*/ 

  • juggler/trunk/modules/gadgeteer/gadget/Node.cpp

    r20138 r20197  
    7979   if (NULL != mSockStream) 
    8080   { 
    81       /* 
    8281      if(mSockStream->isOpen()) 
    8382      { 
    …… 
    8685      delete mSockStream; 
    8786      mSockStream = NULL; 
    88       */ 
    8987   } 
    9088} 
    …… 
    185183   } 
    186184 
     185   // Early out if we only have a header. 
    187186   if(header->getPacketLength() == cluster::Header::RIM_PACKET_HEAD_SIZE) 
    188187   { 
    …… 
    190189   } 
    191190 
    192    // If we have a data packet we need to also send the raw data 
    193    if (outPacket->getPacketType() != cluster::Header::RIM_DATA_PACKET) 
    194    { 
    195       std::vector<vpr::Uint8>* packet_data = outPacket->getData(); 
    196  
    197       try 
    198       { 
    199          mSockStream->send(*packet_data, 
    200             header->getPacketLength() - cluster::Header::RIM_PACKET_HEAD_SIZE); 
    201       } 
    202       catch (vpr::IOException&) 
    203       { 
    204          // TODO: setCause(ex) 
    205          throw cluster::ClusterException("Packet::recv() - Sending data packet failed!!"); 
    206       } 
    207    } 
    208    else 
    209    { 
    210       std::vector<vpr::Uint8>* packet_data = outPacket->getData(); 
    211  
    212       // Since we are sending a DataPacket we are not actually sending all data here. We are only sending 2 GUIDs here 
    213       int size = 32; 
    214  
    215       try 
    216       { 
    217          mSockStream->send(*packet_data, size); 
    218       } 
    219       catch (vpr::IOException&) 
    220       { 
    221          // TODO: setCause(ex) 
    222          throw cluster::ClusterException("Packet::recv() - Sending packet failed!!"); 
    223       } 
    224  
    225  
    226       cluster::DataPacketPtr temp_data_packet 
    227          = boost::dynamic_pointer_cast<cluster::DataPacket>(outPacket); 
    228       vprASSERT(NULL != temp_data_packet.get() && "Dynamic cast failed!"); 
    229  
    230       // Testing GUIDs 
    231       /*vpr::BufferObjectReader* testing = new vpr::BufferObjectReader(packet_data); 
    232       vpr::GUID test; 
    233       test.readObject(testing); 
    234       vpr::GUID test2; 
    235       test2.readObject(testing); 
    236  
    237       std::cout << "1: " << test.toString() << " 2: " << test2.toString() << std::endl; 
    238  
    239       delete testing; 
    240  
    241       // Testing ID 
    242       testing = new vpr::BufferObjectReader(temp_data_packet->getDeviceData()); 
    243       std::cout << "ID: " << (int)testing->readUint16() << std::endl; 
    244  
    245       delete testing; 
    246       */ 
    247  
    248       try 
    249       { 
    250          mSockStream->send(*(temp_data_packet->getDeviceData()), 
    251                            temp_data_packet->getDeviceData()->size()); 
    252       } 
    253       catch (vpr::IOException&) 
    254       { 
    255          // TODO: setCause(ex) 
    256          throw cluster::ClusterException("Packet::recv() - Sending Packet Data failed!!"); 
    257       } 
    258    } 
     191   try 
     192   { 
     193      mSockStream->send(*outPacket->getData(), 
     194         header->getPacketLength() - cluster::Header::RIM_PACKET_HEAD_SIZE); 
     195   } 
     196   catch (vpr::IOException&) 
     197   { 
     198      // TODO: setCause(ex) 
     199      throw cluster::ClusterException("Packet::recv() - Sending data packet failed!!"); 
     200   } 
     201 
    259202   return true; 
    260203} 
    …… 
    307250   // Set the header for the new packet. 
    308251   new_packet->setHeader( packet_head ); 
    309    // Allocate memory for incoming packet. 
    310    std::vector<vpr::Uint8> incoming_data; 
    311252 
    312253   // Make sure that we are connected. 
    …… 
    332273         // Get packet data. 
    333274         mSockStream->recvn( 
    334             incoming_data, 
     275            *new_packet->getData(), 
    335276            packet_head->getPacketLength() - cluster::Header::RIM_PACKET_HEAD_SIZE 
    336277         ); 
    …… 
    349290   } 
    350291 
    351    vpr::BufferObjectReader* reader = new vpr::BufferObjectReader( &incoming_data ); 
    352  
    353292   // Parse Packet with new data 
    354    new_packet->parse( reader ); 
    355  
    356    //NOTE: incoming_data goes out of scope here which means that we are left with only the data that we parsed. 
    357    //TODO: We could save memory by not parsing the raw DataPacket but just passing the location of the memory that we want to use. 
    358  
    359    //parse_data_length = DataPacket::ParsedDataLength 
    360    //recvn(incoming_parse_data, ...) 
    361    //reader = new reader(incoming_parse_data); 
    362    //new_packet->parse(reader); 
    363    //recvn(incoming_raw_data, ...) 
    364    //new_packet->setRawData(incoming_raw_data); 
     293   new_packet->parse(); 
    365294 
    366295   return new_packet; 

  • juggler/trunk/modules/gadgeteer/plugins/ApplicationDataManager/ApplicationDataManager.cpp

    r20186 r20197  
    9595         if (user_data != NULL) 
    9696         { 
    97             // Create a object reader to parse the object's data with 
    98             vpr::BufferObjectReader* temp_reader = 
    99                new vpr::BufferObjectReader(data_packet->getDeviceData()); 
    100  
    10197            // Parse the object's data using the temporary ObjectReader 
    102             user_data->readObject(temp_reader); 
     98            user_data->readObject(data_packet->getPacketReader()); 
    10399         } 
    104100         else 

  • juggler/trunk/modules/gadgeteer/plugins/ApplicationDataManager/ApplicationDataServer.cpp

    r20118 r20197  
    4040   : mApplicationData(userData) 
    4141   , mDataPacket() 
    42    , mBufferObjectWriter(NULL) 
    43    , mDeviceData(NULL) 
     42//   , mBufferObjectWriter(NULL) 
     43//   , mDeviceData(NULL) 
    4444{ 
    4545   // mDataPacket and mBufferObjectWriter both use mDeviceData as their data buffer. 
    46    mDeviceData = new std::vector<vpr::Uint8>; 
     46   //mDeviceData = new std::vector<vpr::Uint8>; 
    4747    
    4848   // Create a DataPacket that will be updated and sent continually. 
    49    mDataPacket = DataPacket::create(pluginGuid, guid, mDeviceData); 
    50    mBufferObjectWriter = new vpr::BufferObjectWriter(mDeviceData); 
     49   mDataPacket = DataPacket::create(pluginGuid, guid); 
     50   //mBufferObjectWriter = new vpr::BufferObjectWriter(mDeviceData); 
    5151} 
    5252 
    …… 
    6464   // to since mDataPacket contains a reference to the ame memory. 
    6565   // vpr::BufferObjectWritter does not release mDeviceData 
    66    delete mBufferObjectWriter; 
    67    mDeviceData = NULL;    
     66   //delete mBufferObjectWriter; 
     67   //mDeviceData = NULL;    
    6868} 
    6969 
    …… 
    7171{ 
    7272   // Clear old data and reset the position of mBufferObjectWriter 
    73    mBufferObjectWriter->getData()->clear(); 
    74    mBufferObjectWriter->setCurPos(0); 
     73   //mBufferObjectWriter->getData()->clear(); 
     74   //mBufferObjectWriter->setCurPos(0); 
     75   mDataPacket->getData()->clear(); 
     76   mDataPacket->getPacketWriter()->setCurPos(0); 
    7577 
    7678   // This updates the mApplicationData which both mBufferedObjectReader and mDevicePacket point to 
    77    mApplicationData->writeObject(mBufferObjectWriter); 
     79   //mApplicationData->writeObject(mBufferObjectWriter); 
     80 
     81   mDataPacket->serialize(*mApplicationData); 
    7882 
    7983   // We must update the size of the actual data that we are going to send 
    …… 
    8185                                    + 16 /*Plugin GUID*/ 
    8286                                    + 16 /*Plugin GUID*/ 
    83                                     + mDeviceData->size()); 
     87                                    + mDataPacket->getData()->size()); 
     88//                                    + mDeviceData->size()); 
    8489 
    8590   // We must serialize the header again so that we can reset the size. 

  • juggler/trunk/modules/gadgeteer/plugins/ApplicationDataManager/ApplicationDataServer.h

    r20116 r20197  
    9595   ApplicationData*             mApplicationData;    /**< Structure that is being shared across the cluster. */ 
    9696   DataPacketPtr                mDataPacket;         /**< Packet will be sent across the cluster. */ 
    97    vpr::BufferObjectWriter*     mBufferObjectWriter; /**< ObjectWriter used to serialize the ApplicationData. */ 
    98    std::vector<vpr::Uint8>*     mDeviceData;         /**< Vector that conatins the data that will be sent across the node */ 
     97//   vpr::BufferObjectWriter*     mBufferObjectWriter; /**< ObjectWriter used to serialize the ApplicationData. */ 
     98//   std::vector<vpr::Uint8>*     mDeviceData;         /**< Vector that conatins the data that will be sent across the node */ 
    9999}; 
    100100 

  • juggler/trunk/modules/gadgeteer/plugins/RIMPlugin/DeviceServer.cpp

    r20118 r20197  
    4343   , mDevice(device) 
    4444   , mDataPacket() 
    45    , mBufferObjectWriter(NULL) 
    46    , mDeviceData(NULL) 
    4745{ 
    4846   vpr::GUID temp; 
    …… 
    5856   while(temp == mId); 
    5957 
    60    mDeviceData = new std::vector<vpr::Uint8>; 
    61    mDataPacket = cluster::DataPacket::create(pluginGuid, mId, mDeviceData); 
    62    mBufferObjectWriter = new vpr::BufferObjectWriter(mDeviceData); 
     58   mDataPacket = cluster::DataPacket::create(pluginGuid, mId); 
    6359} 
    6460 
    …… 
    7167DeviceServer::~DeviceServer() 
    7268{ 
    73    // mDataPacket will clean up the memory that mDeviceData points 
    74    // to since mDataPacket contains a reference to the same memory. 
    75    mDeviceData = NULL; 
    76    delete mBufferObjectWriter; 
    77    mBufferObjectWriter = NULL; 
    7869} 
    7970 
    …… 
    9081void DeviceServer::updateLocalData() 
    9182{ 
    92    // -BufferObjectWriter 
    93    mBufferObjectWriter->getData()->clear(); 
    94    mBufferObjectWriter->setCurPos(0); 
    95  
    9683   vprASSERT(NULL != mDevice.get() && "Can't have a NULL device."); 
    9784 
    98    // This updates the mDeviceData which both mBufferedObjectReader and 
    99    // mDevicePacket point to. 
    100    mDevice->writeObject(mBufferObjectWriter); 
     85   mDataPacket->serialize(*mDevice); 
    10186 
    10287   // We must update the size of the actual data that we are going to send 
    10388   mDataPacket->getHeader()->setPacketLength( 
    10489      cluster::Header::RIM_PACKET_HEAD_SIZE 
    105          + 16 /*Plugin GUID*/ 
    106          + 16 /*Plugin GUID*/ 
    107          + mDeviceData->size() 
     90         + mDataPacket->getData()->size() 
    10891   ); 
    10992 
    …… 
    11497void DeviceServer::debugDump(int debugLevel) const 
    11598{ 
    116  
    11799   vpr::DebugOutputGuard dbg_output( 
    118100      gadgetDBG_RIM, debugLevel, 

  • juggler/trunk/modules/gadgeteer/plugins/RIMPlugin/DeviceServer.h

    r20115 r20197  
    110110   gadget::InputPtr                    mDevice; 
    111111   cluster::DataPacketPtr              mDataPacket; 
    112    vpr::BufferObjectWriter*            mBufferObjectWriter; 
    113    std::vector<vpr::Uint8>*            mDeviceData; 
    114112}; 
    115113 

  • juggler/trunk/modules/gadgeteer/plugins/RIMPlugin/RIMPlugin.cpp

    r20158 r20197  
    260260      case cluster::Header::RIM_DATA_PACKET: 
    261261         { 
    262             cluster::DataPacketPtr temp_data_packet = boost::dynamic_pointer_cast<cluster::DataPacket>(packet); 
    263             vprASSERT(NULL != temp_data_packet.get() && "Dynamic cast failed!"); 
     262            cluster::DataPacketPtr data_packet = boost::dynamic_pointer_cast<cluster::DataPacket>(packet); 
     263            vprASSERT(NULL != data_packet.get() && "Dynamic cast failed!"); 
    264264 
    265265            //vprDEBUG(gadgetDBG_RIM,vprDBG_CONFIG_LVL) << "RIM::handlePacket()..." << std::endl <<  vprDEBUG_FLUSH; 
    266             //temp_data_packet->printData(1); 
    267  
    268             gadget::InputPtr virtual_device = getVirtualDevice(temp_data_packet->getObjectId()); 
     266            //data_packet->printData(1); 
     267 
     268            gadget::InputPtr virtual_device = getVirtualDevice(data_packet->getObjectId()); 
    269269            if ( NULL != virtual_device.get() ) 
    270270            { 
    271                vpr::BufferObjectReader* temp_reader = new vpr::BufferObjectReader(temp_data_packet->getDeviceData()); 
    272  
    273                temp_reader->setAttrib("rim.timestamp.delta", node->getDelta()); 
    274                virtual_device->readObject(temp_reader); 
     271               vpr::BufferObjectReader* reader = data_packet->getPacketReader(); 
     272               reader->setAttrib("rim.timestamp.delta", node->getDelta()); 
     273               virtual_device->readObject(reader); 
    275274            } 
    276275            break;