Skip to contentSkip to conversation

select(0,NULL,NULL,NULL,&t1) used for delay

DISCUSSION Madhu K.S. 8 participants 11 messages Oct 6, 2005 – Oct 10, 2005

lore
Share & tools
lore

Madhu K.S.

author
#0 lore raw

Hi all,

In many application we use select() system call for delay.

example:
select(0,NULL,NULL,NULL,&t1);

select() for delay is very inefficient. I modified sys_select() code for efficiency .Here are the changes to fs/select.c.

Please suggest on these changes.

I know nanosleep() can be used instead of select(), but please suggest on my changes.

file : fs/select.c
function : sys_select()

                          timeout += sec * (unsigned long) HZ;
                }
        }
-
+
+
        ret = -EINVAL;
        if (n < 0)
                goto out_nofds;
-
+       if ( (n == 0) && (inp == NULL) && (outp == NULL) &&
		(exp==	NULL)){
+                printf("\n I am inside new select condition timeout
			%d\n",timeout);
+                set_current_state(TASK_INTERRUPTIBLE);
+                ret = 0;
+                timeout = schedule_timeout(timeout);
+                if (signal_pending(current))

+ ret = -ERESTARTNOHAND;
+ if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
+ time_t sec = 0, usec = 0;
+ if (timeout) {

+                                sec = timeout / HZ;
+                                usec = timeout % HZ;
+                                usec *= (1000000/HZ);
+                        }
+                        put_user(sec, &tvp->tv_sec);
+                        put_user(usec, &tvp->tv_usec);
+                }
+                current->state = TASK_RUNNING;
+                goto out_nofds;
+        }
+
        /* max_fdset can increase, so grab it once to avoid race */
        max_fdset = current->files->max_fdset;
        if (n > max_fdset)

Thank you very much.
Thanks for your assistances.

Madhu K.S.

#1 lore raw
Quoted 5 lines · Madhu K.S.

Hi all,

In many application we use select() system call for delay.

Quoted 9 lines

example:
select(0,NULL,NULL,NULL,&t1);

select() for delay is very inefficient. I modified sys_select() code for efficiency .Here are the changes to fs/select.c.

Please suggest on these changes.

A few tiny comments below.

Quoted 7 lines

I know nanosleep() can be used instead of select(), but please suggest on my changes.

file : fs/select.c
function : sys_select()

Submitting an actual applyable patch is preferred. Makes it possible to easily apply your changes to test the changes and then the file and function is also part of the patch so you won't have to spell that out explicitly.
Use diff -up

Quoted 6 lines


                          timeout += sec * (unsigned long) HZ;
                }
        }

Review

Quoted 9 lines
(quoted diff) +3 -2
-
+
+
        ret = -EINVAL;
        if (n < 0)
                goto out_nofds;
-
+       if ( (n == 0) && (inp == NULL) && (outp == NULL) &&
                (exp==  NULL)){

No space for the beginning parenthesis and space before the opening bracket is preferred:

       if ((n == 0) && (inp == NULL) && (outp == NULL) &&
               (exp==  NULL)) {
Quoted 2 lines

+ printf("\n I am inside new select condition timeout

                        %d\n",timeout);

Having a printk() here certainly won't help performance.

Review

Quoted 5 lines
(quoted diff) +5 -0
+                set_current_state(TASK_INTERRUPTIBLE);
+                ret = 0;
+                timeout = schedule_timeout(timeout);
+                if (signal_pending(current))
+                        ret = -ERESTARTNOHAND;

Wouldn't it make sense to jump out at this point if there's a signal pending?

                if (signal_pending(current)) {
                        ret = -ERESTARTNOHAND;
                        goto out;
                }

Or am I missing something?

Review

Quoted 6 lines
(quoted diff) +6 -0
+                if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
+                        time_t sec = 0, usec = 0;
+                        if (timeout) {
+                                sec = timeout / HZ;
+                                usec = timeout % HZ;
+                                usec *= (1000000/HZ);

Small style thing: usec *= (1000000 / HZ);

Review

Quoted 12 lines
(quoted diff) +8 -0
+                        }
+                        put_user(sec, &tvp->tv_sec);
+                        put_user(usec, &tvp->tv_usec);
+                }
+                current->state = TASK_RUNNING;
+                goto out_nofds;
+        }
+
        /* max_fdset can increase, so grab it once to avoid race */
        max_fdset = current->files->max_fdset;
        if (n > max_fdset)

[snip]

--
Jesper Juhl <[email protected]>
Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
Plain text mails only, please http://www.expita.com/nomime.html

#3 lore raw
In reply to Jesper Juhl
Quoted 2 lines · Jesper Juhl

Or am I missing something?

Insert obligatory joke about optimizing delay loops... ?

Signature · 4 lines
 -- Howard Chu
 Chief Architect, Symas Corp.  http://www.symas.com
 Director, Highland Sun        http://highlandsun.com/hyc
 OpenLDAP Core Team            http://www.openldap.org/project/
#4 lore raw
Quoted 1 line · Howard Chu

Insert obligatory joke about optimizing delay loops... ?

It's not a delay if there's a signal pending.

Chris

#5 lore raw
In reply to Madhu K.S.
Quoted 8 lines · Madhu K.S.

Hi all,

In many application we use select() system call for delay.

example:
select(0,NULL,NULL,NULL,&t1);

select() for delay is very inefficient. I modified sys_select() code for

Why don't you just use nanosleep(2) (or usleep)?

#6 lore raw
Quoted 1 line · Alex Riesen

Why don't you just use nanosleep(2) (or usleep)?

I can think of one main reason...existing code. Also, nanosleep() rounds up excessively in many kernel versions, so that a request to sleep for less than 1 tick ends up sleeping for 2 ticks.

The select() man page explicitly mentions this usage;

"Some code calls select with all three sets empty, n zero, and a non-null timeout as a fairly portable way to sleep with subsecond precision."

Chris

#7 lore raw
Quoted 5 lines · Christopher Friesen
Quoted 1 line · Alex Riesen

Why don't you just use nanosleep(2) (or usleep)?

I can think of one main reason...existing code. Also, nanosleep()

And it's cooler to hack the kernel than to create and use a portable_sleep() function and use it.

Quoted 2 lines

rounds up excessively in many kernel versions, so that a request to sleep for less than 1 tick ends up sleeping for 2 ticks.

                                                  ^^^^^^^
Quoted 4 lines

The select() man page explicitly mentions this usage;

"Some code calls select with all three sets empty, n zero, and a non-null timeout as a fairly portable way to sleep with subsecond

                                                          ^^^^^^^^^
Quoted 1 line

precision."

^^^^^^^^^

You do realize that "subsecond precision" is probably meant as improvement to sleep(3) and surely not to nanosleep(2)?

Bernd

Signature · 3 lines
Firmix Software GmbH                   http://www.firmix.at/
mobil: +43 664 4416156                 fax: +43 1 7890849-55
          Embedded Linux Development and Services
#8 lore raw
Quoted 4 lines · Bernd Petrovitsch

On Thu, 2005-10-06 at 09:26 -0600, Christopher Friesen wrote:

And it's cooler to hack the kernel than to create and use a portable_sleep() function and use it.

If there is a substantial codebase using select() for sleeping, then it makes sense to improve the efficiency of the kernel. Fix it in one place, make all the apps run better.

Quoted 9 lines
Quoted 3 lines

The select() man page explicitly mentions this usage;

"Some code calls select with all three sets empty, n zero, and a non-null timeout as a fairly portable way to sleep with subsecond

                                                          ^^^^^^^^^
Quoted 1 line

precision."

^^^^^^^^^

You do realize that "subsecond precision" is probably meant as improvement to sleep(3) and surely not to nanosleep(2)?

select() allows for the selection of sleep time with microsecond precision. The mainline kernel can't sleep for that small an interval anyway, so there's not really any difference in sleep precision between the two.

As I mentioned earlier, select() actually sleeps more accurately than nanosleep() on many kernels. I haven't tested the most recent to see if this is still true though.

Chris

#9 lore raw
In reply to Christopher Friesen
Quoted 5 lines

The select() man page explicitly mentions this usage;

"Some code calls select with all three sets empty, n zero, and a non-null timeout as a fairly portable way to sleep with subsecond precision."

Perl's documentation also notes it as one of the many ways to do a subsecond sleep:

Quoted 3 lines

You can effect a sleep of 250 milliseconds this way:

                 select(undef, undef, undef, 0.25);

TMTOWTDI.

#10 lore raw
In reply to Alex Riesen
Quoted 6 lines · Alex Riesen
Quoted 4 lines · Madhu K.S.

Hi all,

In many application we use select() system call for delay.

Quoted 7 lines
Quoted 4 lines

example:
select(0,NULL,NULL,NULL,&t1);

select() for delay is very inefficient. I modified sys_select() code for

Why don't you just use nanosleep(2) (or usleep)?

I think the answers here are (a) because there's an existing code base, and (b) as long as the functionality is required it might as well be provided optimally. If tou're going to do something at all, do it right.

Signature · 3 lines
   -bill davidsen ([email protected])
"The secret to procrastination is to put things off until the
 last possible moment - but no longer"  -me