Hello After lurking on the team for several months I now have a query, I am currently working on a real time system - and have been for several months and one of my areas of responsibility has been system performance. We have been measuring performance of various tasks using a logic analyser and a simple instrumentation which "logs on" and "off" via a simple system of writing to a specific address in memory and then monitoring writes with the logic analyser. Whilst this was fine for initial investigation, it is quite long winded and technical for pure software engineers to gather performance data. and we plan to implement a solution which records performance data continuously. Each task (in the curent system) runs on a predefined cycle time - that is it performs its functions and then delays to make the cycle time up (delay current_time - (start_time - cycle_time)). I am aware that this is not a very clever way of doing things but the redesign required to remove the inherent problems with this design will come later. My best solution for this at the moment works in prototype and is implemented as a task which accepts a sign on and a sign off from a list of tasks and maintains which task is running. So a task signs on after it's delay and signs off after it has finished processing. When another task signs on before the one being currently monitored signs off timing for the current task is suspended (ie the time at which this happened is recorded) and monitoring of the new task is started. When a task signs off the task that had its time suspended before the other task signed on has its timing resumed with an appropriate adjustment to account for the time taken by the other task. The basic Ada structure for this is a follows task body Time_Monitoring_Task_Type is Local_Task : Task_Type; begin loop accept Start_Monitoring; loop select accept Reset_Data; Reset_Data; or accept Report_Data; -- report data with appropriate method Report_Data; or accept Sign_On(The_Task : in Task_Type) do Local_Task := The_Task; end Sign_On; -- Sign on the task and pause monitoring of current task if necessary Sign_On(Local_Task); or accept Sign_Off(The_Task : in Task_Type) do Local_Task := The_Task; end Sign_Off; -- Sign off the task and resume monitoring of last task Sign_Off(Local_Task); or accept Stop_Monitoring; exit; end select; end loop; Apart from syntax, errors which are bound to be in the above has anyone any comments on the suitability of this algorithm given that the sign_on and sign_off are significantly complex and will consume a significant amount of procesing. If you require any further information details of the sign_on and sign_off routines can be supplied. I would be very grateful for any of your advice. John Ross Galagrip Ltd. (Director) http://www.galagrip.demon.co.uk/index.htm Any opinions expressed or otherwise are also my actual opinions.