Here is a paper written by Willian Chen of SunLabs. He proposes a change
to the CPC (CPU Performance Counters) subsystem whereby Solaris will
buffer overflow events in the kernel.
In the interests of soliciting feedback from community members and being
more public about the types of changes we're considering for Solaris,
I'm posting this here for all to see and comment on before we submit it
to PSARC.
-------
Project name : CPC in-kernel buffering
Project summary :
CPC in-kernel buffering adds a counter buffer such that the user can
request the kernel to throw an overflow interrupt when the counter
buffer overflows.
Business Summary :
Any application that requires low sampling overhead might benefit from
in-kernel buffering. Our experiment shows that on average, 6-10%
runtime can be saved using cpc in-kernel buffering.
Run-Time Dynamic Optimizer is a user of the CPC in-kernel buffering to
reduce sampling overhead and to achieve better SPEC numbers. Run-time
Dynamic Optimizer is also targetting commercial applications, such as
Oracle, that do not ship profile-optimized binaries.
Profile collection of cache information for various compilers is another
client for in-kernel buffering.
Technical Description :
Counter overflow interrupt is one usage of libcpc. Upon counter
overflow, the likely useful information is the PC value of the
instruction which triggered the event which caused the overflow. If the
user is expected to accumulate a number of counter samples before the
collected information becomes useful, then its possible to aggregate
multiple counter overflow interrupts into a single interrupt by storing
the counter samples into a PC buffer (ie. counter overflows are deferred
and saved in the in-kernel buffer until the buffer overflows and only by
then is the SIG_EMT delivered).
This proposal enhances libcpc with one additional command
'CPC_OVF_BUFFERED', and the function 'cpc_set_sample_pcbuf' to read the
PC samples. By specifying CPC_OVF_BUFFERED, the user indicates that the
PC information should be saved into the buffer of size 'CPC_PCBUF_SIZE'
upon counter overflow, and uses the function cpc_set_sample_pcbuf for
reading.
For example to trigger an interrupt only when the in-kernel buffer is
filled, the user would add CPC_OVF_BUFFERED into the cpc request command
as follows.
cpc_set_add_request(cpc, set, name, period,
(CPC_COUNTER_USER | CPC_OVF_NOTIFY_EMT | CPC_OVF_BUFFERED),
0, NULL);
And in the EMT handler, cpc_set_sample_pcbuf is called to copy back the
buffered PC values into a user specified buffered area. After calling
cpc_set_sample_pcbuf, the kernel buffer must be cleared.
High level overview of the proposed changes are as follows.
1. Create a new command CPC_OVF_BUFFERED.
2. Define size of PC buffer CPC_PCBUF_SIZE.
3. Implement cpc_set_sample_pcbuf to complement cpc_set_sample.
4. Implement kcpc_sample_pcbuf to complement kcpc_sample.
5. Modify kcpc_overflow_ast to buffer samples if command
CPC_OVF_BUFFERED is issued.
Here is the proposed prototype for the new functions.
int cpc_set_sample_pcbuf(cpc_t *cpc, cpc_set_t *set, cpc_buf_t *buf,
uint64_t *pcbuf);
int kcpc_sample_pcbuf(kcpc_set_t *set, uint64_t *buf, hrtime_t *hr_time,
uint64_t *tick);
Here is the proposed change to the prototype of existing function.
int kcpc_overflow_ast(uint64_t pc);
Limitations :
1. Only PC values are stored in the buffer.
Thanks to William for this contribution. There were a few responses to
this inside Sun which I will post shortly.
- Russ
-----------------------------------------------------
Russ Blaine | Solaris Kernel | [EMAIL PROTECTED]
_______________________________________________
perf-discuss mailing list
perf-discuss@opensolaris.org
