[lkml]   [2004]   [Sep]   [2]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
SubjectRe: [RFC][PATCH] new timeofday core subsystem (v.A0)
On Thu, 2004-09-02 at 15:42, Christoph Lameter wrote:
> On Thu, 2 Sep 2004, john stultz wrote:
> > What about my idea from yesterday of inverting the fastcall
> > relationship? Instead of creating a structure that exports values and
> > pointers the fastcall can use to create a time of day, why not use the
> > fast call to read the raw time and return it back to the time of day
> > code (which may be running in user context)? This avoids the duplication
> > of having to re-implement the timeofday/clock_gettime functions in
> > fastcall asm code.
> "Read raw time"? How can you read the raw time in a fast call if the
> fast call needs to do additional function calls (as defined in the
> proposed time structure) in the kernel context in order to retrieve time?
> A fast call cannot do any function calls in the kernel context or
> otherwise.
> The overhead of the function calls will reduce the performance of time
> access significantly.

Forgive me if I mis-understand the fastcall method, but this is the
concept. Instead of having a fastcall function that implmements the
gettimofday/clock_gettime + ntp scaling + etc all in asm we do the

When creating a ia64 timesource (say the cyclone just for a specific
example) we do something like the following.

/* trivial delta (nothing new here) */
static cycle_t cyclone_fastcall_delta(cycle_t now, cycle_t then)
return (now - then);
/* trivial cyc2ns (nothing new here) */
static nsec_t cyclone_fastcall_cyc2ns(cycle_t cyc, cycle_t* remainder)
u64 rem;
cyc *= freq_multiplier;
if (remainder)
*remainder = 0;
return (nsec_t)cyc;

/* fastcall read, this is where it gets interesting */
static cycle_t cyclone_fasatcall_read(void)
u64 ret;

ret = fastcall_readcyclonecounter();

return (cycle_t)ret;

struct timesource_t timesource_cyclone_fastcall = {
.name = "cyclone_fastcall",
.priority = 100,
.read = cyclone_fastcall_read,
.delta = cyclone_fastcall_delta,
.cyc2ns = cyclone_fastcall_cyc2ns,

Then you implement a fastcall for fastcall_readcyclonecounter(), which
in crazy ia64 asm would do something like:

blip // magic privledge escalation
blop // load cyclone counter into memory
bloop // copy cyclone counter back into return register

This avoids 150+ lines of asm needed to re-implement the gettimeofday

However, I could be mistaken. Is something like this possible?


To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to
More majordomo info at
Please read the FAQ at

 \ /
  Last update: 2005-03-22 14:05    [W:0.100 / U:0.036 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site