Experiences using "register"

[Spiros Bousbouras]

Has anyone found that declaring variables register affected
speed of execution ? If yes on what hardware and around
which year ?

[CBFalconer]

Richard Tobin wrote:

Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrote:

>"An example of proper use:

for (register int i= 0; i < INT_MAX; ++i)
array[i] *= i;

Is there *any* C compiler out there that accepts this syntax but
has such a useless optimiser that using "register" is worthwhile?
A loop variable has to be the most obvious case where any
reasonable compiler will use a register anyway.

I seriously doubt that example. If any element of a[] is greater
than 1 it will cause overflow, and un or implementation defined
action.

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home .att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Ioannis Vranos]

CBFalconer wrote:

Richard Tobin wrote:

>Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrote:

>>"An example of proper use:

for (register int i= 0; i < INT_MAX; ++i)
array[i] *= i;

Is there *any* C compiler out there that accepts this syntax but
has such a useless optimiser that using "register" is worthwhile?
A loop variable has to be the most obvious case where any
reasonable compiler will use a register anyway.

I seriously doubt that example. If any element of a[] is greater
than 1 it will cause overflow, and un or implementation defined
action.

Consider sizeof(array)/sizeof(*array)= = INT_MAX and the elements of the
array being 1s and 0s.

[Richard]

Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrites:

CBFalconer wrote:

>Richard Tobin wrote:

>>Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrote:

"An example of proper use:

for (register int i= 0; i < INT_MAX; ++i)
array[i] *= i;
Is there *any* C compiler out there that accepts this syntax but
has such a useless optimiser that using "register" is worthwhile?
A loop variable has to be the most obvious case where any
reasonable compiler will use a register anyway.

I seriously doubt that example. If any element of a[] is greater
than 1 it will cause overflow, and un or implementation defined
action.

Consider sizeof(array)/sizeof(*array)= = INT_MAX and the elements of the
array being 1s and 0s.

Don't worry, you're just witnessing the wondrous Chuck being obstructive
and pedantic as usual. Everyone else knew what you were driving at.

[Ioannis Vranos]

Richard wrote:

>If the function is more than 5-6 lines of code, "register" should not be
used for the function scope but only for local scopes in the function
(like small loops).

Where do you get these "facts" that you maintain are true with zero to
back them up? It all depends on the compiler and also depend, in a
larger function, on how often your register variable was used and how it
was used. Length in lines has absolutely nothing to do with it.

The smaller the scope, the less effect it has on the rest of code. Where
do you disagree with this?

[Willem]

Ioannis wrote:
) Richard wrote:
)>If the function is more than 5-6 lines of code, "register" should not be
)>used for the function scope but only for local scopes in the function
)>(like small loops).
)>
)Where do you get these "facts" that you maintain are true with zero to
)back them up? It all depends on the compiler and also depend, in a
)larger function, on how often your register variable was used and how it
)was used. Length in lines has absolutely nothing to do with it.
)
) The smaller the scope, the less effect it has on the rest of code. Where
) do you disagree with this?

You're arguing in circles again.
Why should 'register' be used only when it has minimal effect on the code ?
SaSW, Willem
--
Disclaimer: I am in no way responsible for any of the statements
made in the above text. For all I know I might be
drugged or something..
No I'm not paranoid. You all think I'm paranoid, don't you !
#EOT

[Ioannis Vranos]

Willem wrote:

Ioannis wrote:
) Richard wrote:
)>If the function is more than 5-6 lines of code, "register" should not be
)>used for the function scope but only for local scopes in the function
)>(like small loops).
)>
)Where do you get these "facts" that you maintain are true with zero to
)back them up? It all depends on the compiler and also depend, in a
)larger function, on how often your register variable was used and how it
)was used. Length in lines has absolutely nothing to do with it.
)
) The smaller the scope, the less effect it has on the rest of code. Where
) do you disagree with this?

You're arguing in circles again.
Why should 'register' be used only when it has minimal effect on the code ?

Why "inline" should be used with small functions only?

[Richard]

Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrites:

Willem wrote:

>Ioannis wrote:
) Richard wrote:
)>If the function is more than 5-6 lines of code, "register" should not be
)>used for the function scope but only for local scopes in the function
)>(like small loops).
)>
)Where do you get these "facts" that you maintain are true with zero to
)back them up? It all depends on the compiler and also depend, in a
)larger function, on how often your register variable was used and how it
)was used. Length in lines has absolutely nothing to do with it.
)
) The smaller the scope, the less effect it has on the rest of code. Where
) do you disagree with this?

You're arguing in circles again.
Why should 'register' be used only when it has minimal effect on the code ?

Why "inline" should be used with small functions only?

Because it adversely affects code size is one thing I can think of ...

[Ioannis Vranos]

Richard wrote:

Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrites:

>Willem wrote:

>>Ioannis wrote:
) Richard wrote:
)>If the function is more than 5-6 lines of code, "register" should not be
)>used for the function scope but only for local scopes in the function
)>(like small loops).
)>
)Where do you get these "facts" that you maintain are true with zero to
)back them up? It all depends on the compiler and also depend, in a
)larger function, on how often your register variable was used and how it
)was used. Length in lines has absolutely nothing to do with it.
)
) The smaller the scope, the less effect it has on the rest of code. Where
) do you disagree with this?

You're arguing in circles again.
Why should 'register' be used only when it has minimal effect on the code ?

Why "inline" should be used with small functions only?

Because it adversely affects code size is one thing I can think of ...

Exactly. "register" should be used in as a small scope as possible, so
as it affects (or better: doesn't affect) code that is not intended to
be affected.

[Ioannis Vranos]

Corrected:

Ioannis Vranos wrote:

Richard wrote:

>Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrites:

>>Willem wrote:
Ioannis wrote:
) Richard wrote:
)>If the function is more than 5-6 lines of code, "register" should not be
)>used for the function scope but only for local scopes in the function
)>(like small loops).
)>
)Where do you get these "facts" that you maintain are true with zero to
)back them up? It all depends on the compiler and also depend, in a
)larger function, on how often your register variable was used and how it
)was used. Length in lines has absolutely nothing to do with it.
)
) The smaller the scope, the less effect it has on the rest of code. Where
) do you disagree with this?

You're arguing in circles again.
Why should 'register' be used only when it has minimal effect on the code ?
Why "inline" should be used with small functions only?

Because it adversely affects code size is one thing I can think of ...

Exactly. "register" should be used in as a small scope as possible, so
as it doesn't affect code that is not intended to be affected.

[Harald van =?UTF-8?b?RMSzaw==?=]

On Sun, 30 Mar 2008 16:55:58 +0200, Richard wrote:

Ioannis Vranos <iv*****@nospam .no.spamfreemai l.grwrites:

>Willem wrote:

>>You're arguing in circles again.
Why should 'register' be used only when it has minimal effect on the
code ?

Why "inline" should be used with small functions only?

Because it adversely affects code size is one thing I can think of ...

If the function is huge, but it's only called from one place, inlining
may even decrease the code size.