Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Altered LLIndexedVector. There's zero point to having a lookup map into an array like this. Just iterating down the array is faster than the map lookup (which iterates down a linked list...). A hash map would be a different case entirely.

Browse Source
This commit is contained in:
Shyotl
2018-10-12 02:07:45 -05:00
parent 55ad048b3a
commit 0b4d789afb
12 changed files with 37 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
indra/llcommon/llindexedvector.h
View File

@@ -40,14 +40,14 @@ template <typename Type, typename Key, int BlockSize = 32>
class LLIndexedVector
{
public:
typedef typename std::vector<Type>::iterator iterator;
typedef typename std::vector<Type>::const_iterator const_iterator;
typedef typename std::vector<Type>::reverse_iterator reverse_iterator;
typedef typename std::vector<Type>::const_reverse_iterator const_reverse_iterator;
typedef typename std::vector<Type>::size_type size_type;
typedef typename std::vector<std::pair<Key, Type> > vec_type_t;
typedef typename vec_type_t::iterator iterator;
typedef typename vec_type_t::const_iterator const_iterator;
typedef typename vec_type_t::reverse_iterator reverse_iterator;
typedef typename vec_type_t::const_reverse_iterator const_reverse_iterator;
typedef typename vec_type_t::size_type size_type;
protected:
std::vector<Type> mVector;
std::map<Key, U32> mIndexMap;
std::vector<std::pair<Key, Type> > mVector;
public:
LLIndexedVector() { mVector.reserve(BlockSize); }
@@ -68,32 +68,12 @@ public:
Type& operator[](const Key& k)
{
typename std::map<Key, U32>::const_iterator iter = mIndexMap.find(k);
if (iter == mIndexMap.end())
{
U32 n = mVector.size();
mIndexMap[k] = n;
mVector.push_back(Type());
llassert(mVector.size() == mIndexMap.size());
return mVector[n];
}
else
{
return mVector[iter->second];
}
return get_val_in_pair_vec(mVector, k);
}
const_iterator find(const Key& k) const
{
typename std::map<Key, U32>::const_iterator iter = mIndexMap.find(k);
if(iter == mIndexMap.end())
{
return mVector.end();
}
else
{
return mVector.begin() + iter->second;
}
return std::find_if(mVector.begin(), mVector.end(), [&k](const typename vec_type_t::value_type& e) { return e.first == k; });
}
};

1
indra/llmessage/llmessagebuilder.h
View File

@@ -49,7 +49,6 @@ public:
virtual void newMessage(const char* name) = 0;
virtual void nextBlock(const char* blockname) = 0;
virtual BOOL removeLastBlock() = 0; // TODO: babbage: remove this horror
/** All add* methods expect pointers to canonical strings. */
virtual void addBinaryData(

9
indra/llmessage/llmessagetemplate.cpp
View File

@@ -30,8 +30,12 @@
#include "message.h"
U32 sMsgDataAllocSize = 0;
U32 sMsgdataAllocCount = 0;
void LLMsgVarData::addData(const void *data, S32 size, EMsgVariableType type, S32 data_size)
{
sMsgDataAllocSize += size;
mSize = size;
mDataSize = data_size;
if ( (type != MVT_VARIABLE) && (type != MVT_FIXED)
@@ -45,6 +49,7 @@ void LLMsgVarData::addData(const void *data, S32 size, EMsgVariableType type, S3
}
if(size)
{
++sMsgdataAllocCount;
delete[] mData; // Delete it if it already exists
mData = new U8[size];
htonmemcpy(mData, data, mType, size);
@@ -120,7 +125,7 @@ std::ostream& operator<<(std::ostream& s, LLMessageBlock &msg)
for (LLMessageBlock::message_variable_map_t::iterator iter = msg.mMemberVariables.begin();
iter != msg.mMemberVariables.end(); iter++)
{
LLMessageVariable& ci = *(*iter);
LLMessageVariable& ci = *iter->second;
s << ci;
}
@@ -164,7 +169,7 @@ std::ostream& operator<<(std::ostream& s, LLMessageTemplate &msg)
for (LLMessageTemplate::message_block_map_t::iterator iter = msg.mMemberBlocks.begin();
iter != msg.mMemberBlocks.end(); iter++)
{
LLMessageBlock* ci = *iter;
LLMessageBlock* ci = iter->second;
s << *ci;
}

15
indra/llmessage/llmessagetemplate.h
View File

@@ -32,6 +32,8 @@
#include "llstl.h"
#include "llindexedvector.h"
extern U32 sMsgDataAllocSize;
extern U32 sMsgdataAllocCount;
class LLMsgVarData
{
public:
@@ -86,7 +88,7 @@ public:
for (msg_var_data_map_t::iterator iter = mMemberVarData.begin();
iter != mMemberVarData.end(); iter++)
{
iter->deleteData();
iter->second.deleteData();
}
}
@@ -119,7 +121,6 @@ public:
~LLMsgData()
{
for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePairedPointer());
mMemberBlocks.clear();
}
void addBlock(LLMsgBlkData *blockp)
@@ -130,7 +131,7 @@ public:
void addDataFast(char *blockname, char *varname, const void *data, S32 size, EMsgVariableType type, S32 data_size = -1);
public:
typedef std::map<char*, LLMsgBlkData*> msg_blk_data_map_t;
typedef LLIndexedVector<LLMsgBlkData*, char*> msg_blk_data_map_t;
msg_blk_data_map_t mMemberBlocks;
char *mName;
S32 mTotalSize;
@@ -187,7 +188,7 @@ public:
~LLMessageBlock()
{
for_each(mMemberVariables.begin(), mMemberVariables.end(), DeletePointer());
for_each(mMemberVariables.begin(), mMemberVariables.end(), DeletePairedPointer());
}
void addVariable(char *name, const EMsgVariableType type, const S32 size)
@@ -222,7 +223,7 @@ public:
const LLMessageVariable* getVariable(char* name) const
{
message_variable_map_t::const_iterator iter = mMemberVariables.find(name);
return iter != mMemberVariables.end()? *iter : NULL;
return iter != mMemberVariables.end()? iter->second : NULL;
}
friend std::ostream& operator<<(std::ostream& s, LLMessageBlock &msg);
@@ -294,7 +295,7 @@ public:
~LLMessageTemplate()
{
for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePointer());
for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePairedPointer());
}
void addBlock(LLMessageBlock *blockp)
@@ -388,7 +389,7 @@ public:
const LLMessageBlock* getBlock(char* name) const
{
message_block_map_t::const_iterator iter = mMemberBlocks.find(name);
return iter != mMemberBlocks.end()? *iter : NULL;
return iter != mMemberBlocks.end() ? iter->second : NULL;
}
public:

9
indra/llmessage/llsdmessagebuilder.cpp
View File

@@ -95,13 +95,6 @@ void LLSDMessageBuilder::nextBlock(const char* blockname)
}
}
// TODO: Remove this horror...
BOOL LLSDMessageBuilder::removeLastBlock()
{
/* TODO: finish implementing this */
return FALSE;
}
void LLSDMessageBuilder::addBinaryData(
const char* varname,
const void* data,
@@ -264,7 +257,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data)
for(; dit != dend; ++dit)
{
const LLMsgVarData& mvci = *dit;
const LLMsgVarData& mvci = dit->second;
const char* varname = mvci.getName();
switch(mvci.getType())

1
indra/llmessage/llsdmessagebuilder.h
View File

@@ -48,7 +48,6 @@ public:
virtual void newMessage(const char* name);
virtual void nextBlock(const char* blockname);
virtual BOOL removeLastBlock(); // TODO: babbage: remove this horror...
/** All add* methods expect pointers to canonical varname strings. */
virtual void addBinaryData(

75
indra/llmessage/lltemplatemessagebuilder.cpp
View File

@@ -89,7 +89,7 @@ void LLTemplateMessageBuilder::newMessage(const char *name)
iter != msg_template->mMemberBlocks.end();
++iter)
{
LLMessageBlock* ci = *iter;
LLMessageBlock* ci = iter->second;
LLMsgBlkData* tblockp = new LLMsgBlkData(ci->mName, 0);
mCurrentSMessageData->addBlock(tblockp);
}
@@ -151,7 +151,7 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname)
for (LLMessageBlock::message_variable_map_t::const_iterator iter = template_data->mMemberVariables.begin();
iter != template_data->mMemberVariables.end(); iter++)
{
LLMessageVariable& ci = **iter;
LLMessageVariable& ci = *iter->second;
mCurrentSDataBlock->addVariable(ci.getName(), ci.getType());
}
return;
@@ -212,76 +212,13 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname)
end = template_data->mMemberVariables.end();
iter != end; iter++)
{
LLMessageVariable& ci = **iter;
LLMessageVariable& ci = *iter->second;
mCurrentSDataBlock->addVariable(ci.getName(), ci.getType());
}
return;
}
}
// TODO: Remove this horror...
BOOL LLTemplateMessageBuilder::removeLastBlock()
{
if (mCurrentSBlockName)
{
if ( (mCurrentSMessageData)
&&(mCurrentSMessageTemplate))
{
if (mCurrentSMessageData->mMemberBlocks[mCurrentSBlockName]->mBlockNumber >= 1)
{
// At least one block for the current block name.
// Store the current block name for future reference.
char *block_name = mCurrentSBlockName;
// Decrement the sent total by the size of the
// data in the message block that we're currently building.
const LLMessageBlock* template_data = mCurrentSMessageTemplate->getBlock(mCurrentSBlockName);
for (LLMessageBlock::message_variable_map_t::const_iterator iter = template_data->mMemberVariables.begin();
iter != template_data->mMemberVariables.end(); iter++)
{
LLMessageVariable& ci = **iter;
mCurrentSendTotal -= ci.getSize();
}
// Now we want to find the block that we're blowing away.
// Get the number of blocks.
LLMsgBlkData* block_data = mCurrentSMessageData->mMemberBlocks[block_name];
S32 num_blocks = block_data->mBlockNumber;
// Use the same (suspect?) algorithm that's used to generate
// the names in the nextBlock method to find it.
char *block_getting_whacked = block_name + num_blocks - 1;
LLMsgBlkData* whacked_data = mCurrentSMessageData->mMemberBlocks[block_getting_whacked];
delete whacked_data;
mCurrentSMessageData->mMemberBlocks.erase(block_getting_whacked);
if (num_blocks <= 1)
{
// we just blew away the last one, so return FALSE
LL_WARNS() << "not blowing away the only block of message "
<< mCurrentSMessageName
<< ". Block: " << block_name
<< ". Number: " << num_blocks
<< LL_ENDL;
return FALSE;
}
else
{
// Decrement the counter.
block_data->mBlockNumber--;
return TRUE;
}
}
}
}
return FALSE;
}
// add data to variable in current block
void LLTemplateMessageBuilder::addData(const char *varname, const void *data, EMsgVariableType type, S32 size)
{
@@ -665,7 +602,7 @@ static S32 buildBlock(U8* buffer, S32 buffer_size, const LLMessageBlock* templat
for (LLMsgBlkData::msg_var_data_map_t::const_iterator iter = mbci->mMemberVarData.begin();
iter != mbci->mMemberVarData.end(); iter++)
{
const LLMsgVarData& mvci = *iter;
const LLMsgVarData& mvci = iter->second;
if (mvci.getSize() == -1)
{
// oops, this variable wasn't ever set!
@@ -821,7 +758,7 @@ U32 LLTemplateMessageBuilder::buildMessage(
iter != end;
++iter)
{
result += buildBlock(buffer + result, buffer_size - result, *iter, mCurrentSMessageData);
result += buildBlock(buffer + result, buffer_size - result, iter->second, mCurrentSMessageData);
}
mbSBuilt = TRUE;
@@ -864,7 +801,7 @@ void LLTemplateMessageBuilder::copyFromMessageData(const LLMsgData& data)
for(; dit != dend; ++dit)
{
const LLMsgVarData& mvci = *dit;
const LLMsgVarData& mvci = dit->second;
addData(mvci.getName(), mvci.getData(), mvci.getType(), mvci.getSize());
}
}

1
indra/llmessage/lltemplatemessagebuilder.h
View File

@@ -49,7 +49,6 @@ public:
virtual void newMessage(const char* name);
virtual void nextBlock(const char* blockname);
virtual BOOL removeLastBlock(); // TODO: babbage: remove this horror...
/** All add* methods expect pointers to canonical varname strings. */
virtual void addBinaryData(const char *varname, const void *data,

4
indra/llmessage/lltemplatemessagereader.cpp
View File

@@ -554,7 +554,7 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender,
iter != mCurrentRMessageTemplate->mMemberBlocks.end();
++iter)
{
LLMessageBlock* mbci = *iter;
LLMessageBlock* mbci = iter->second;
U8 repeat_number;
S32 i;
@@ -621,7 +621,7 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender,
mbci->mMemberVariables.begin();
iter != mbci->mMemberVariables.end(); iter++)
{
const LLMessageVariable& mvci = **iter;
const LLMessageVariable& mvci = *iter->second;
// ok, build out the variables
// add variable block

8
indra/llmessage/message.cpp
View File

@@ -1001,14 +1001,6 @@ BOOL LLMessageSystem::isSendFullFast(const char* blockname)
return mMessageBuilder->isMessageFull(blockname);
}
// blow away the last block of a message, return FALSE if that leaves no blocks or there wasn't a block to remove
// TODO: Babbage: Remove this horror.
BOOL LLMessageSystem::removeLastBlock()
{
return mMessageBuilder->removeLastBlock();
}
S32 LLMessageSystem::sendReliable(const LLHost &host)
{
return sendReliable(host, LL_DEFAULT_RELIABLE_RETRIES, TRUE, LL_PING_BASED_TIMEOUT_DUMMY, NULL, NULL);

2
indra/llmessage/message.h
View File

@@ -457,8 +457,6 @@ public:
BOOL isSendFull(const char* blockname = NULL);
BOOL isSendFullFast(const char* blockname = NULL);
BOOL removeLastBlock();
//void buildMessage();
S32 zeroCode(U8 **data, S32 *data_size);

8
indra/newview/llfloatermessagelog.cpp
View File

@@ -90,7 +90,7 @@ LLFloaterMessageLogItem::LLFloaterMessageLogItem(LLMessageLogEntry entry)
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
blocks_iter != blocks_end; ++blocks_iter)
{
LLMessageBlock* block = (*blocks_iter);
LLMessageBlock* block = blocks_iter->second;
const char* block_name = block->mName;
S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name);
if(!num_blocks)
@@ -104,7 +104,7 @@ LLFloaterMessageLogItem::LLFloaterMessageLogItem(LLMessageLogEntry entry)
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
var_iter != var_end; ++var_iter)
{
LLMessageVariable* variable = (*var_iter);
LLMessageVariable* variable = var_iter->second;
const char* var_name = variable->getName();
BOOL returned_hex;
std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex, TRUE);
@@ -183,7 +183,7 @@ std::string LLFloaterMessageLogItem::getFull(BOOL show_header)
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
blocks_iter != blocks_end; ++blocks_iter)
{
LLMessageBlock* block = (*blocks_iter);
LLMessageBlock* block = blocks_iter->second;
const char* block_name = block->mName;
S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name);
for(S32 i = 0; i < num_blocks; i++)
@@ -193,7 +193,7 @@ std::string LLFloaterMessageLogItem::getFull(BOOL show_header)
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
var_iter != var_end; ++var_iter)
{
LLMessageVariable* variable = (*var_iter);
LLMessageVariable* variable = var_iter->second;
const char* var_name = variable->getName();
BOOL returned_hex;
std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex);