Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
_______________________________________________ Devel mailing list Devel@sel4.systemsmailto:Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Actually, is there any easy way to get all TCBs even from within the kernel? I see ksReadyQueues has all the runnable TCBs, but what about the rest?
-Andrew
On Tue, Jan 17, 2017 at 7:29 PM, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Unfortunately the kernel does not have a way of finding all the TCBs that have been created in the system. You would have to manipulate the TCB creation/deletion code to maintain a linked list of all the created TCBs.
To call raw system calls just make sure you #include <sel4/sel4.h> and then yes, you can just directly call them from any component code.
Adrian
On Wed 18-Jan-2017 1:10 PM, Andrew Gacek wrote:
Actually, is there any easy way to get all TCBs even from within the kernel? I see ksReadyQueues has all the runnable TCBs, but what about the rest?
-Andrew
On Tue, Jan 17, 2017 at 7:29 PM, Andrew Gacek andrew.gacek@gmail.commailto:andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.aumailto:Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
_______________________________________________ Devel mailing list Devel@sel4.systemsmailto:Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
I got an error when enabling benchmarking:
/home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h: In function 'handleOverflowIRQ': /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: implicit declaration of function 'armv_handleOverflowIRQ' [-Werror=implicit-function-declaration] armv_handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: nested extern declaration of 'armv_handleOverflowIRQ' [-Werror=nested-externs]
I'll just hack around it, but I thought you guys would want to know.
-Andrew
On Tue, Jan 17, 2017 at 9:04 PM, Ihor.Kuz@data61.csiro.au wrote:
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Thanks again Adrian and Ihor for the help. I was able to get something working which was good enough for my needs.
In case anybody else is interested, I made a small change to the kernel to get the TCB names back from seL4_SysBenchmarkGetThreadUtilisation():
https://github.com/agacek/seL4/commit/d46d8bda0de9f359ddd5a121072da8fbd78dd5...
I modified camkes to give a component called 'perfmon' access to all TCB caps:
https://github.com/agacek/camkes-tool/commit/4a1c21f441ce0fa57879c29756e4908...
Then I created a user space perfmon component which would generate a report when requested:
https://github.com/smaccm/smaccm/commit/1eb9c5ce4cb1cb5475de7f832a1b69065f1e...
Most of this is brittle and hacked together of course, but it was good enough for me to see how much of the CPU each component was using. Here's some sample output from my application:
86.3% Virtual_Machine_inst.vm_shim_obj(1) (cap 0x22) 2.8% CAN_Driver_inst.spi_obj(5) (cap 0x37) 2.2% CAN_Driver_inst.spi_obj(7) (cap 0x26) 1.3% dispatch_periodic_inst(3) (cap 0x21) 1.1% CAN_Driver_inst.gpio_obj(7) (cap 0x17) 0.7% UART_Driver_inst.uart_shim_obj(6) (cap 0x42) 0.7% time_server.time_server(8) (cap 0x3e) 0.6% CAN_Framing_inst(9) (cap 0x28) 0.6% Decrypt_inst(7) (cap 0x2d) ...
-Andrew
On Wed, Jan 18, 2017 at 8:16 AM, Andrew Gacek andrew.gacek@gmail.com wrote:
I got an error when enabling benchmarking:
/home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h: In function 'handleOverflowIRQ': /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: implicit declaration of function 'armv_handleOverflowIRQ' [-Werror=implicit-function-declaration] armv_handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: nested extern declaration of 'armv_handleOverflowIRQ' [-Werror=nested-externs]
I'll just hack around it, but I thought you guys would want to know.
-Andrew
On Tue, Jan 17, 2017 at 9:04 PM, Ihor.Kuz@data61.csiro.au wrote:
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Hi Andrew,
Regarding the error you get when you enable benchmarks, which kernel revision are you using? This error should be fixed after this commit (530852b) [1].
[1] https://github.com/seL4/seL4/commit/530852bbdc31b7bbc2ba920c4299714896ba0cd4
Cheers, Hesham ________________________________________ From: Devel devel-bounces@sel4.systems on behalf of Andrew Gacek andrew.gacek@gmail.com Sent: Thursday, January 19, 2017 8:17 AM To: Kuz, Ihor (Data61, Kensington NSW) Cc: Danis, Adrian (Data61, Kensington NSW); devel@sel4.systems Subject: Re: [seL4] seL4 System Utilization / Benchmark
Thanks again Adrian and Ihor for the help. I was able to get something working which was good enough for my needs.
In case anybody else is interested, I made a small change to the kernel to get the TCB names back from seL4_SysBenchmarkGetThreadUtilisation():
https://github.com/agacek/seL4/commit/d46d8bda0de9f359ddd5a121072da8fbd78dd5...
I modified camkes to give a component called 'perfmon' access to all TCB caps:
https://github.com/agacek/camkes-tool/commit/4a1c21f441ce0fa57879c29756e4908...
Then I created a user space perfmon component which would generate a report when requested:
https://github.com/smaccm/smaccm/commit/1eb9c5ce4cb1cb5475de7f832a1b69065f1e...
Most of this is brittle and hacked together of course, but it was good enough for me to see how much of the CPU each component was using. Here's some sample output from my application:
86.3% Virtual_Machine_inst.vm_shim_obj(1) (cap 0x22) 2.8% CAN_Driver_inst.spi_obj(5) (cap 0x37) 2.2% CAN_Driver_inst.spi_obj(7) (cap 0x26) 1.3% dispatch_periodic_inst(3) (cap 0x21) 1.1% CAN_Driver_inst.gpio_obj(7) (cap 0x17) 0.7% UART_Driver_inst.uart_shim_obj(6) (cap 0x42) 0.7% time_server.time_server(8) (cap 0x3e) 0.6% CAN_Framing_inst(9) (cap 0x28) 0.6% Decrypt_inst(7) (cap 0x2d) ...
-Andrew
On Wed, Jan 18, 2017 at 8:16 AM, Andrew Gacek andrew.gacek@gmail.com wrote:
I got an error when enabling benchmarking:
/home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h: In function 'handleOverflowIRQ': /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: implicit declaration of function 'armv_handleOverflowIRQ' [-Werror=implicit-function-declaration] armv_handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: nested extern declaration of 'armv_handleOverflowIRQ' [-Werror=nested-externs]
I'll just hack around it, but I thought you guys would want to know.
-Andrew
On Tue, Jan 17, 2017 at 9:04 PM, Ihor.Kuz@data61.csiro.au wrote:
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
_______________________________________________ Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Hi Hesham,
I am using the master branch of seL4 which includes that commit. Here's how to duplicate the error:
repo init -u https://github.com/seL4/camkes-manifest.git repo sync make arm_simple_defconfig make menuconfig # enable benchmarks make
On Wed, Jan 18, 2017 at 4:11 PM, Hesham.Almatary@data61.csiro.au wrote:
Hi Andrew,
Regarding the error you get when you enable benchmarks, which kernel revision are you using? This error should be fixed after this commit (530852b) [1].
[1] https://github.com/seL4/seL4/commit/530852bbdc31b7bbc2ba920c4299714896ba0cd4
Cheers, Hesham ________________________________________ From: Devel devel-bounces@sel4.systems on behalf of Andrew Gacek andrew.gacek@gmail.com Sent: Thursday, January 19, 2017 8:17 AM To: Kuz, Ihor (Data61, Kensington NSW) Cc: Danis, Adrian (Data61, Kensington NSW); devel@sel4.systems Subject: Re: [seL4] seL4 System Utilization / Benchmark
Thanks again Adrian and Ihor for the help. I was able to get something working which was good enough for my needs.
In case anybody else is interested, I made a small change to the kernel to get the TCB names back from seL4_SysBenchmarkGetThreadUtilisation():
https://github.com/agacek/seL4/commit/d46d8bda0de9f359ddd5a121072da8fbd78dd5...
I modified camkes to give a component called 'perfmon' access to all TCB caps:
https://github.com/agacek/camkes-tool/commit/4a1c21f441ce0fa57879c29756e4908...
Then I created a user space perfmon component which would generate a report when requested:
https://github.com/smaccm/smaccm/commit/1eb9c5ce4cb1cb5475de7f832a1b69065f1e...
Most of this is brittle and hacked together of course, but it was good enough for me to see how much of the CPU each component was using. Here's some sample output from my application:
86.3% Virtual_Machine_inst.vm_shim_obj(1) (cap 0x22) 2.8% CAN_Driver_inst.spi_obj(5) (cap 0x37) 2.2% CAN_Driver_inst.spi_obj(7) (cap 0x26) 1.3% dispatch_periodic_inst(3) (cap 0x21) 1.1% CAN_Driver_inst.gpio_obj(7) (cap 0x17) 0.7% UART_Driver_inst.uart_shim_obj(6) (cap 0x42) 0.7% time_server.time_server(8) (cap 0x3e) 0.6% CAN_Framing_inst(9) (cap 0x28) 0.6% Decrypt_inst(7) (cap 0x2d) ...
-Andrew
On Wed, Jan 18, 2017 at 8:16 AM, Andrew Gacek andrew.gacek@gmail.com wrote:
I got an error when enabling benchmarking:
/home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h: In function 'handleOverflowIRQ': /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: implicit declaration of function 'armv_handleOverflowIRQ' [-Werror=implicit-function-declaration] armv_handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: nested extern declaration of 'armv_handleOverflowIRQ' [-Werror=nested-externs]
I'll just hack around it, but I thought you guys would want to know.
-Andrew
On Tue, Jan 17, 2017 at 9:04 PM, Ihor.Kuz@data61.csiro.au wrote:
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Hi Andrew,
Thanks for reporting this. This issue only exists for KZM/ARMv6. I submitted a fix internally (1d8be141afa). Should be pushed to github by tomorrow.
Cheers,
Hesham ________________________________________ From: Andrew Gacek andrew.gacek@gmail.com Sent: Thursday, January 19, 2017 9:18 AM To: Almatary, Hesham (Data61, Kensington NSW) Cc: devel@sel4.systems Subject: Re: [seL4] seL4 System Utilization / Benchmark
Hi Hesham,
I am using the master branch of seL4 which includes that commit. Here's how to duplicate the error:
repo init -u https://github.com/seL4/camkes-manifest.git repo sync make arm_simple_defconfig make menuconfig # enable benchmarks make
On Wed, Jan 18, 2017 at 4:11 PM, Hesham.Almatary@data61.csiro.au wrote:
Hi Andrew,
Regarding the error you get when you enable benchmarks, which kernel revision are you using? This error should be fixed after this commit (530852b) [1].
[1] https://github.com/seL4/seL4/commit/530852bbdc31b7bbc2ba920c4299714896ba0cd4
Cheers, Hesham ________________________________________ From: Devel devel-bounces@sel4.systems on behalf of Andrew Gacek andrew.gacek@gmail.com Sent: Thursday, January 19, 2017 8:17 AM To: Kuz, Ihor (Data61, Kensington NSW) Cc: Danis, Adrian (Data61, Kensington NSW); devel@sel4.systems Subject: Re: [seL4] seL4 System Utilization / Benchmark
Thanks again Adrian and Ihor for the help. I was able to get something working which was good enough for my needs.
In case anybody else is interested, I made a small change to the kernel to get the TCB names back from seL4_SysBenchmarkGetThreadUtilisation():
https://github.com/agacek/seL4/commit/d46d8bda0de9f359ddd5a121072da8fbd78dd5...
I modified camkes to give a component called 'perfmon' access to all TCB caps:
https://github.com/agacek/camkes-tool/commit/4a1c21f441ce0fa57879c29756e4908...
Then I created a user space perfmon component which would generate a report when requested:
https://github.com/smaccm/smaccm/commit/1eb9c5ce4cb1cb5475de7f832a1b69065f1e...
Most of this is brittle and hacked together of course, but it was good enough for me to see how much of the CPU each component was using. Here's some sample output from my application:
86.3% Virtual_Machine_inst.vm_shim_obj(1) (cap 0x22) 2.8% CAN_Driver_inst.spi_obj(5) (cap 0x37) 2.2% CAN_Driver_inst.spi_obj(7) (cap 0x26) 1.3% dispatch_periodic_inst(3) (cap 0x21) 1.1% CAN_Driver_inst.gpio_obj(7) (cap 0x17) 0.7% UART_Driver_inst.uart_shim_obj(6) (cap 0x42) 0.7% time_server.time_server(8) (cap 0x3e) 0.6% CAN_Framing_inst(9) (cap 0x28) 0.6% Decrypt_inst(7) (cap 0x2d) ...
-Andrew
On Wed, Jan 18, 2017 at 8:16 AM, Andrew Gacek andrew.gacek@gmail.com wrote:
I got an error when enabling benchmarking:
/home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h: In function 'handleOverflowIRQ': /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: implicit declaration of function 'armv_handleOverflowIRQ' [-Werror=implicit-function-declaration] armv_handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: nested extern declaration of 'armv_handleOverflowIRQ' [-Werror=nested-externs]
I'll just hack around it, but I thought you guys would want to know.
-Andrew
On Tue, Jan 17, 2017 at 9:04 PM, Ihor.Kuz@data61.csiro.au wrote:
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Thanks Hesham. I also had an issue when I compiled for the Jetson Tegra K1:
[CC] kernel_final.s In file included from /home/ajgacek/phase3-workspace/camkes/kernel/include/arch/arm/arch/32/mode/machine.h:19:0, from /home/ajgacek/phase3-workspace/camkes/kernel/include/machine.h:17, from /home/ajgacek/phase3-workspace/camkes/kernel/include/api/syscall.h:14, from /home/ajgacek/phase3-workspace/camkes/kernel/src/api/faults.c:16: /home/ajgacek/phase3-workspace/camkes/kernel/include/plat/tk1/plat/machine/hardware.h: In function 'handleReservedIRQ': /home/ajgacek/phase3-workspace/camkes/kernel/include/plat/tk1/plat/machine/hardware.h:157:9: error: implicit declaration of function 'handleOverflowIRQ' [-Werror=implicit-function-declaration] handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/camkes/kernel/include/plat/tk1/plat/machine/hardware.h:157:9: error: nested extern declaration of 'handleOverflowIRQ' [-Werror=nested-externs] cc1: all warnings being treated as errors /home/ajgacek/phase3-workspace/camkes/kernel/Makefile:611: recipe for target 'kernel_final.s' failed make[1]: *** [kernel_final.s] Error 1 tools/common/project.mk:254: recipe for target 'kernel_elf' failed make: *** [kernel_elf] Error 2
On Thu, Jan 19, 2017 at 12:20 AM, Hesham.Almatary@data61.csiro.au wrote:
Hi Andrew,
Thanks for reporting this. This issue only exists for KZM/ARMv6. I submitted a fix internally (1d8be141afa). Should be pushed to github by tomorrow.
Cheers,
Hesham ________________________________________ From: Andrew Gacek andrew.gacek@gmail.com Sent: Thursday, January 19, 2017 9:18 AM To: Almatary, Hesham (Data61, Kensington NSW) Cc: devel@sel4.systems Subject: Re: [seL4] seL4 System Utilization / Benchmark
Hi Hesham,
I am using the master branch of seL4 which includes that commit. Here's how to duplicate the error:
repo init -u https://github.com/seL4/camkes-manifest.git repo sync make arm_simple_defconfig make menuconfig # enable benchmarks make
On Wed, Jan 18, 2017 at 4:11 PM, Hesham.Almatary@data61.csiro.au wrote:
Hi Andrew,
Regarding the error you get when you enable benchmarks, which kernel revision are you using? This error should be fixed after this commit (530852b) [1].
[1] https://github.com/seL4/seL4/commit/530852bbdc31b7bbc2ba920c4299714896ba0cd4
Cheers, Hesham ________________________________________ From: Devel devel-bounces@sel4.systems on behalf of Andrew Gacek andrew.gacek@gmail.com Sent: Thursday, January 19, 2017 8:17 AM To: Kuz, Ihor (Data61, Kensington NSW) Cc: Danis, Adrian (Data61, Kensington NSW); devel@sel4.systems Subject: Re: [seL4] seL4 System Utilization / Benchmark
Thanks again Adrian and Ihor for the help. I was able to get something working which was good enough for my needs.
In case anybody else is interested, I made a small change to the kernel to get the TCB names back from seL4_SysBenchmarkGetThreadUtilisation():
https://github.com/agacek/seL4/commit/d46d8bda0de9f359ddd5a121072da8fbd78dd5...
I modified camkes to give a component called 'perfmon' access to all TCB caps:
https://github.com/agacek/camkes-tool/commit/4a1c21f441ce0fa57879c29756e4908...
Then I created a user space perfmon component which would generate a report when requested:
https://github.com/smaccm/smaccm/commit/1eb9c5ce4cb1cb5475de7f832a1b69065f1e...
Most of this is brittle and hacked together of course, but it was good enough for me to see how much of the CPU each component was using. Here's some sample output from my application:
86.3% Virtual_Machine_inst.vm_shim_obj(1) (cap 0x22) 2.8% CAN_Driver_inst.spi_obj(5) (cap 0x37) 2.2% CAN_Driver_inst.spi_obj(7) (cap 0x26) 1.3% dispatch_periodic_inst(3) (cap 0x21) 1.1% CAN_Driver_inst.gpio_obj(7) (cap 0x17) 0.7% UART_Driver_inst.uart_shim_obj(6) (cap 0x42) 0.7% time_server.time_server(8) (cap 0x3e) 0.6% CAN_Framing_inst(9) (cap 0x28) 0.6% Decrypt_inst(7) (cap 0x2d) ...
-Andrew
On Wed, Jan 18, 2017 at 8:16 AM, Andrew Gacek andrew.gacek@gmail.com wrote:
I got an error when enabling benchmarking:
/home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h: In function 'handleOverflowIRQ': /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: implicit declaration of function 'armv_handleOverflowIRQ' [-Werror=implicit-function-declaration] armv_handleOverflowIRQ(); ^ /home/ajgacek/phase3-workspace/perf/kernel/include/arch/arm/arch/benchmark_overflowHandler.h:22:9: error: nested extern declaration of 'armv_handleOverflowIRQ' [-Werror=nested-externs]
I'll just hack around it, but I thought you guys would want to know.
-Andrew
On Tue, Jan 17, 2017 at 9:04 PM, Ihor.Kuz@data61.csiro.au wrote:
You should be able to call seL4 syscalls from a CAmkES component. Just include the right headers (and link the library if necesary).
Note that if the syscalls require caps, then you are on your own wrt how to get the caps.
Ihor
On 18 Jan 2017, at 12:29 pm, Andrew Gacek andrew.gacek@gmail.com wrote:
Thanks Adrian. This is a useful start. It sounds like the easiest thing may be to overwrite some syscall that I don't use to loop over all the threads in the kernel and print out their debugging info.
Also, I've never called raw seL4 system calls from a camkes component before. Is it just a matter of calling seL4_BenchmarkResetLog() or seL4_BenchmarkFinalizeLog() directly in the control code for one of my components?
-Andrew
On Tue, Jan 17, 2017 at 7:23 PM, Adrian.Danis@data61.csiro.au wrote:
Hi Andrew,
There is some code already in the kernel to help you do this, although it is tested and fixed on an as used basis so may or may not work as I describe. You can enable the the thread utilization tracking with make menuconfig -> seL4 Kernel -> Build Options -> Enable benchmarks -> Track threads and kernel utilisation time Once enabled you gain the following relevant functions
seL4_BenchmarkResetLog() Reset idle time and total run time and start capturing utilization information
seL4_BenchmarkFinalizeLog() Calculate idle time, total run time and stop capturing utilization information
seL4_BenchmarkGetThreadUtilisation(seL4_Word tcb_cptr) Retrieve the utilization for a particular thread where seL4_GetMR(0) == Thread utilization (in cycles) of this (tcb_cptr) thread seL4_GetMR(1) == Idle thread utilization (in cycles) between the last call to Reset and Finalize log seL4_GetMR(2) == Totall execution time (in cycles) between the last call to Reset and Finalize log
seL4_BenchmarkResetThreadUtilisation(seL4_Word tcb_cptr) Reset the utilization of this thread.
The main problem with this API is that it requires you to have caps to all the threads you wish to get the information of, which in CAmkES is generally only the capdl-loader application. It is also designed with the idea that you want to reset the utilization counts at the point you're querying them, i.e. you're doing some kind of benchmark and you just want utilization over that benchmark.
Hope this provides some use to you.
Adrian
On Wed 18-Jan-2017 9:59 AM, Andrew Gacek wrote:
Hi,
I'm interested in seeing how much of the CPU is being used by the various threads in my (camkes) application. I'd like a simple "Task Manager" style report of the form:
70% idle 25% can_obj_7_0_control_9_tcb 5% can_obj_7_Int_3_0000_tcb 0% can_obj_7_0_fault_handler_15_ 0000_tcb etc
I've tried poking around libsel4bench, but I don't see any obvious way of benchmarking the whole system. From what I can tell, it's mostly designed to get cycle counts from specific code segments. Is that right? What's the best way to go about benchmarking the whole system? It's only for debugging, so I'm willing to make some quick-and-dirty changes to the kernel just to see the results.
Thanks, Andrew
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
Devel mailing list Devel@sel4.systems https://sel4.systems/lists/listinfo/devel
-
Adrian.Danis＠data61.csiro.au -
Andrew Gacek -
Hesham.Almatary＠data61.csiro.au -
Ihor.Kuz＠data61.csiro.au