Optimizing application performance

[Airslash]

Hello,

not really sure if this is the correct place to ask this, but here goes:

I'm currently working on an application that uses the client-server model to accomplish the following:

- The server grabs images from camera's and stores them on disk.
- The server application talks to the grabber software and obtains the absolute path to the bitmap files.
- The client asks the server application for an image and gets it in jpeg.

The idea behind this is to simulate a videostream by delivering the images in sequence fast enough. Currently I'm encountering the following issues:

- FPS is only 2, I think i'm loosing alot of overhead in the TCP traffic.
- Server goes up to 100% load. My believe is that the altering of bitmap -> jpeg sucks up all available resources.

I'm basicly looking for some guides or information about image processing and client-server architecture. The application is written in C# and relies in .NET 4.0.
I can provide the test application or parts of the code.

            // Cast the data we recieved to a string.
            string message = Encoding.ASCII.GetString(data);
 
            // Check if we have an @CAMNR message
            if (message.Contains("@CAMNR:"))
            {
                Invoke(new MethodInvoker(delegate { m_debug.Items.Add("message recieved : " + message); }));
 
                // Strip the last symbol and the @CAMNR: part.
                message = message.Substring(7, (message.Length - 1) - "@CAMNR:".Length);
 
                WriteMessage("stripped message : " + message);
 
                    // Load the image.
                Image img = Image.FromFile(message);
 
                // Load the image into a memorystream.
                MemoryStream fullstream = new MemoryStream();
                MemoryStream image_stream = new MemoryStream();
 
                // Load the image into the image_stream buffer.
                img.Save(image_stream, System.Drawing.Imaging.ImageFormat.Jpeg);
 
                // Create the byte arrays that represent the header tag and the size.
                byte[] header = Encoding.ASCII.GetBytes("@IMG:");
                byte[] size = BitConverter.GetBytes(((int)image_stream.Length));    // Assume ints, since we only need 4 bytes.
 
                //DEBUG
                WriteMessage("File size according FileInfo class: " + new FileInfo(message).Length.ToString() + " bytes.");
                WriteMessage("File size according Array Length: " + image_stream.Length.ToString() + " bytes");
                WriteMessage("File size as int representation : " + ((int)image_stream.Length).ToString() + " bytes");
 
                // Append the data to the memorystream.
                fullstream.Write(header, 0, header.Length);
                fullstream.Write(size, 0, size.Length);
                fullstream.Write(image_stream.ToArray(), 0, image_stream.ToArray().Length);
 
                WriteMessage("Image loaded into the memorystream.");
 
                // Convert the entire memorystream into an byte array.
                byte[] buffer = fullstream.ToArray();
 
                // Start pumping out the data over the network socket. This will be done in several bursts depending
                // on the settings of the network.
                m_client.GetStream().Write(buffer, 0, buffer.Length);
 
                WriteMessage("Image send to client.");
            }
 

This is the code that I use to respond on a image request. It loads the bitmap, turns it into a jpeg and delivers it to the client. My guess is, that the biggers overhead problem exists here already, but this sort of uncharted teritory for me.

[Oralloy]

Well, if the server load is 100%, I can almost guarantee that your 2FPS is not due to TCP/IP overhead.

There are a couple things you can do
1) You can pre-convert the bitmaps to jpeg images
2) You can send unconverted bitmaps

Otherwise, you should just buy an off-the-shelf package and have done with.

Good Luck!

[Joseph Martell]

When it comes to optimization one of the ideas that I see coming up all the time is to make sure you are solving the right problem.

One of the first things that I would do is create a basic logging class that can be used to log how long specific portions of your program take. Right now you are guessing that the TCP/IP overhead and image conversion is what is killing your FPS, but that is just a guess. Your program also has file i/o, which can be slow, and it is executing a bunch of framework code behind the scenes. You may be surprised what is eating your processing time.

All of these are guesses until you do some diagnostics to find out where your time is actually being spent. I wouldn't want to optimize my image conversion code to death only to find out that I had a .Net Framework TCP/IP setting that caused poor performance.

[Airslash]

In all my quickness & sillyness I forgot to add Thread.Sleep calls in certain functions for what a Thread has nothing to do....

Now the CPU load has been reduced to 0 :)
Only other problem I have now, is that the sleeping threads mess up my TCP communication, because they don't respond fast enough.

Guess I'll have to change a bit in the protocol and make it more event driven instead of linear messages.

[Oralloy]

I still find it quite difficult to believe that the TCP/IP throughput is affecting your frame rate.

Well, I can imagine how, but you'd have to be using a slow-speed connection like 9600 baud SLIP. Either that, or your network is so loaded that you really are suffering throughput problems, in which case you'd have noticed the problem long before this.

Give your event driven model a try and let us know how it works out.

Cheers!

[Airslash]

I've written a new class that handles everything through timers, and i still couldn't get above 10FPS, while theoritcly i should hit 60FPS.

After searching a bit, it seems my applications always needs to wait 100ms to recieve an UDP reply from a third application that tells where the image is located.
So I can never breach the 10FPS barrier as long as the third application doesn't speed up.

[Joseph Martell]

Sounds like you'll either need to settle for 10fps or buffer your images.

[Airslash]

Probably,
but I'm defo poking the devs of the third application.
Waiting 100ms on loopback for an UDP reply is not acceptable.

[Oralloy]

Can you turn down that 100ms, or is that just the inherent response time of the third application, and something you can't affect?

[Airslash]

it's the response time of the application, and would require a serious overhaul I think it make it faster.

It's build on 10year old legacy code and constantly beeing added to;....
So to adjust something in there is like playing with matches in a TNT factory...

[Oralloy]

Awwww, you're no fun any more....

:)

Good Luck and A Great Day!

[Airslash]

guess that's what happens when you have to deal with legacy code....:P

Now I just need to make the other's accept the problem is theirs and not mine :S

[Oralloy]

Well, ask them if they want the 60 frames/sec.

If they do, then they need to provide reasonable resources to resolve the legacy system performance/delay issue. And, they should be aware of the possibility that a timing tweak can far exceed the work necessary to change a simple delay timer, and be prepared to pay for it.

Good luck!