Re: vector, but without the overhead of dynamic memory allocation
"Goran" <goran.pusic@gmail.com> wrote in message
news:55bd9b44-8df2-4b34-8cc9-81b4d6f41296@r4g2000vbq.googlegroups.com...
On Mar 9, 4:25 am, Virchanza <virt...@lavabit.com> wrote:
I'm currently writing a program that deals with containers which
contain containers which contain containers.
I'm simplifying things here a bit, but what I have is something like:
class Port_Data {};
class IP_Data {
vector<Port_Data> ports;
};
class MAC_Data {
vector<IP_Data> ips;
};
class SnifferDatabase {
vector<MAC_Data> macs;
};
SnifferDatabase *const g_sdb = new SnifferDatabase();
The program works but it's way too slow. What's slowing things down is
the vector class's use of "malloc/new" to allocate memory (this can be
improved slightly by calling reserve() on the vectors beforehand).
Once you've done a sufficiently big vector::reserve, there is no
additional allocation done by the vector. And yet, you say that this
improved things slightly. That is a clear-cut indication that
allocations done by the vector are not a problem (because there aren't
any!).
IOW... If you don't show your actual code, your performance results,
and your performance requirements, on an OPTIMIZED build, I don't
believe you, and you should not believe yourself when saying this,
either.
I put this to you: your problem is more likely to be in excessive
copying of things. (Re)allocation might be a problem, I am not denying
that in general, but I don't think that's your case, and I don't think
that you exhausted first rule of performance: eliminate busywork
(first target: random copying of stuff).
Yes the code needs to be copy optimised and also I think Juha has made a
good point.
What is seems to need is ownership of the array/vector in the SnifferDB , I
think in pointers so I use dynamics arrays(ofc you could have pointers to
vectors):
class port_data{};
class IP_data{
port_data* p_port;
virtual void reserve(int val, port_data* p_data){};
public:
void reserve(int val){reserve(val, p_port);};
};
class MAC_data{
IP_data* p_ip;
virtual void reserve(int val, IP_data* p_data){};
public:
void reserve(int val){reserve(val, p_ip);}
};
class SnifferDB: public IP_data, public MAC_data{
MAC_data* p_mac;
void reserve(int val, IP_data* p_data){/*Allocate IP_data*/;}
void reserve(int val, port_data* p_data){/*Allocate port_data*/;}
};
So in the end you have 1 polymorphic object with 3 pointers, and easy access
to each array/vectors.
If you want to pass the data around just pass a pointer and no copying is
needed. Depending on program design it may require the flexiblity of a
common Interfase for IP_Data, MAC_data and port_data. This would then be a
diamond inheretance design though and this may introduce some complexity
with the virtual functions.