Calculating a operational rate? E.g. Checking X per second - delphi

Question

I want to be able to calculate the rate at which my software is performing look ups. The software is iterating over a listbox which contains usernames, and then querying my server. I want to calculate how many username look ups I am performing every second?
Would I have to use a timer that executes the calculation every 1000 m/secs? I really have no idea where to start.
I don't have any code to show, just wanted to get some pseudo code.

Answer 1

This might help (I don't really know delphi, so cannot verify syntax, it's only pseudo-code per request):
var
// Set a timer and counter variable
timer : TDateTime;
rate, counter : Integer;
n : Integer; // Iterator
begin
timer := Time;
counter := 0;
for n := 0 to list.items.count - 1 do
begin
// Do the processing here
// add 1 to the counter every time you iterate over a username
counter := counter + 1;
end;
// Divide Time difference by total to get the rate of username lookups per second
// TDateTime is counted in days, convert it to seconds, to get "per sec" rate
rate := counter / ((Time - timer) * 24 * 60 * 60);

Answer 2

If you wanna see aproximate number of lockups your program does per second you might be able to do that with TTimer.
First you need to have soume counter in your loop to count how many items has been processed:
for n := 0 to list.items.count - 1 do
begin
// Do the processing here
// add 1 to the counter every time you iterate over a username
counter := counter + 1;
end;
Then in the OnTimer event of your Timer you check the current counter state and output that to label. And finally you reset your counter to zero:
procedure TForm1.Timer1Timer(Sender: TObject);
begin
//read the coutner value to find out how many items was processed
Label1.Caption := IntToStr(Counter);
//reset timer to zero
Counter := 0;
end;
Now this will give you aproximate results of how many items was processed in the last second. Why only aproximate? TTimer is a windows message based component. What this means is that it doesen't guarantees precision so OnTimer events might not be fired exactly on specified intervals. I have seen deviation even up to half a second. It laregly depends on your main program code and overal system utilization.
NOTE: This approach won't work if you are doing all of this processing in main program thread as such processing could lock up your application till the loop ends. And this means that your application won't process any windows based messages, including the messages that agre created in order to fire the timers OnTimer event.
In such case I recomend next approach. Instead of measuring how many items is processed in one second measure how much time takes to process X amount of items.
You can do this with something like this:
const X := 20; //Constant defining how many items needs to be processed
//before processing time is evaluated
//You will need to find out which number of items is best
//suitable for you on your own by trial and error.
var
//StopWatch is a special record which alows precision timing
sw: TStopWatch;;
//Variable for storing elapsed milliseconds of one measuring cycle
elapsedMilliseconds : cardinal;
//Estimated number of calculations that would have been processed in one
//second
CalculationsPerSecond: Integer;
begin
counter := 0;
//Initialize the stop watch
sw := TStopWatch.Create() ;
//Start stopwatch
sw.Start;
for n := 0 to list.items.count - 1 do
begin
// Do the processing here
// add 1 to the counter every time you iterate over a username
counter := counter + 1;
//Check if the counter has been set to specific number of cycles
//you want to to measure time taken for
if Counter = X then
begin
//Stop the StopWatch
sw.Stop;
//Get how many milliseconds have elapsed since start
elapsedMilliseconds := sw.ElapsedMilliseconds;
//Calculate estimated number of items that would have been processed
//per second
CalculationsPerSecond := Round(1000 * X / elapsedMillisecond);
//Reset counter to zero fopr next cycle
counter := 0;
//Reset stopwatch to zero for next cycle
sw.Reset;
//Start stopwatch agina for next cycle
sw.Start;
end;
//Stop the StopWatch since we no longer need it
sw.Stop;
//Free up the stopwatch record to free up the used memory
sw.Free;
end;