Tuesday, December 13, 2005

 

Filter interface

The filter interface almost done. As the push principle is much easier to implement than the standard pull it should not be so difficult to port all my filters to use the new paradigm. Another thing which will come in handy is the iostream adaptor for stream::Buffer. This can then serve as a drop in substitute for wool::swappable_data.

Wednesday, December 07, 2005

 

Asynchronous DNS

DNS lookups in Dusa will be done using GNUs adns library. The whole concept fits nicely into the framework: DNS query will be an event emitter and its owner would 'consume' these events. The only issue which remains is to make the DNS event poller register the FDs which he uses and work as an event consumer for the IO poller. This way we wont have to poll him in each Application cycle which could get us some latency improvement.

 

Event passing

I have been working on the event passing mechanism in the last month. It is taking its final form and I am pretty happy with it. More tests are needed in order to see if the system does not impose any significant performance limitations. The good thing about it is that a lot of synchronization just becomes obsolete (and all sync issues along with it).

Tuesday, October 11, 2005

 

Performance tests

Well, the performance tests went just lovely. The proxy had about 250-300MBit throughput when hit with 1000 parallel users (about ~6000 connections). What turned out to be a very nice side effect is that memory usage was under 10M. This is VERY nice but also shows that I need to work some more on the Heap class (if the heap does not do more in memory operations when there are 1000 users hitting the machine then when should it?). All in all I am very satisfied.

 

At last, performance tests

A very nice performance analysis devide from spirent (Spirent home page) has been put at my disposal for a couple of hours. I'll see if I can tune the system so I get some convincing data for my theory. This will be the first real test for the prototype.

 

TCP_CORK

Found an interesting, linux specific tcp socket option. It is called TCP_CORK and what it does is prevent the kernel from sending non-full tcp frames. This should improve performance but has certain implications. The main problem is that we don't want the content to be kept in the buffer for 'too long' (and how long is too long?). So we have to make sure we uncork the socket if we want the data to be sent immediately. The approach I am using for Flora is that we keep the socket corked as long as we know that there is more data coming. As soon as the socket buffer becomes empty we uncork the connection and let any lingering data to be sent to the client.

Thursday, October 06, 2005

 

And thus it begins...

A first pre-alpha stage is here. It compiles :) and even better... it runs. It seems that there is a problem with mapped page sync and linux's sendfile. Already talked to some people and it seems to be a chaching issue. We'll see how it goes ;)...

This page is powered by Blogger. Isn't yours?