9 Jun
2005
9 Jun
'05
8:21 a.m.
On Thu, 9 Jun 2005 10:05 , 'Chris Cannam' <chris.cannam(a)ferventsoftware.com>
sent:
I was under the impression that there was bounds checking going on with
vectors. Is this not the case?
Jan
N Smethurst:
iterator in the gcc library had at some point changed from an actual pointer to a
wrapper class. Looking at the code, though, the wrapper is so thin that it
probably isn't an issue with optimization on.
Since a vector is a wrapped C array (i.e.
contigous), the [] operator
compiles to the C equivalent when optimisation is turned on.
I was thinking of iterator operations, having vaguely recalled that the vector
9 Jun
9 Jun
9:02 a.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
eviltwin69(a)cableone.net wrote:
I was under the impression that there was bounds checking going on with
vectors. Is this not the case?
Not necesserally: if you are using operator (), yes, if you use operator
[], no.
David
9:08 a.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
David Cournapeau wrote:
eviltwin69(a)cableone.net wrote:
Sorry, you should read "vec.at(index) does bound checking, not
vec[index]"
David
I was under the impression that there was bounds checking going on
with
vectors. Is this not the case?
Not necesserally: if you are using operator (), yes, if you use
operator [], no.
David
9:56 a.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
David Cournapeau wrote:
eviltwin69(a)cableone.net wrote:
I think you are all guessing.
At least wil C arrays you kopw exactly what you get :-).
Erik
--
+-----------------------------------------------------------+
Erik de Castro Lopo nospam(a)mega-nerd.com (Yes it's valid)
+-----------------------------------------------------------+
"...Please don't assume Lisp is only useful for Animation and
Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining,
EDA/Semiconductor applications, Expert Systems, Finance,
Intelligent Agents, Knowledge Management, Mechanical CAD,
Modeling and Simulation, Natural Language, Optimization, Research,
Risk Analysis, Scheduling, Telecom, and Web Authoring just because
these are the only things they happened to list." -- Kent Pitman
I was under the impression that there was bounds checking going on with
vectors. Is this not the case?
Not necesserally: if you are using operator (), yes, if you use operator
[], no.
11:31 a.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On 6/9/05, Erik de Castro Lopo <erikd-lad(a)mega-nerd.com> wrote:
David Cournapeau wrote:
No, I am not. I cannot find the information on the C++ faq right now,
but If m pretty sure that it is written in the book of Stroustrup.
I did a small test mself: if you check the assembly code of g++ for
the functions
void c_array(int * a)
{
a[5]
}
void vector(vector<int> a)
{
a[5]
}
void vector(vector<int> a)
{
a.at(5)
}
you will see that the assembly code for c_array and vector are quite
similar ( I don't know much about assembly, but here is the output of
g++ -O3 -S for c_array :
.file "c_array.cpp"
.text
.align 2
.p2align 4,,15
.globl _Z7c_arrayPi
.type _Z7c_arrayPi, @function
_Z7c_arrayPi:
.LFB529:
pushl %ebp
.LCFI0:
movl %esp, %ebp
.LCFI1:
movl 8(%ebp), %edx
movl $0, 20(%edx)
popl %ebp
ret
.LFE529:
.size _Z7c_arrayPi, .-_Z7c_arrayPi
.weak pthread_mutex_unlock
.weak pthread_mutex_trylock
.weak pthread_mutex_lock
.weak pthread_create
.weak pthread_setspecific
.weak pthread_getspecific
.weak pthread_key_delete
.weak pthread_key_create
.weak pthread_once
.section .note.GNU-stack,"",@progbits
.ident "GCC: (GNU) 3.3.6 (Debian 1:3.3.6-5)"
and for void vector(vector<int> v)
.file "vector.cpp"
.text
.align 2
.p2align 4,,15
.globl _Z6vectorSt6vectorIiSaIiEE
.type _Z6vectorSt6vectorIiSaIiEE, @function
_Z6vectorSt6vectorIiSaIiEE:
.LFB539:
.L2:
.L7:
pushl %ebp
.LCFI0:
movl %esp, %ebp
.LCFI1:
popl %ebp
ret
.LFE539:
.size _Z6vectorSt6vectorIiSaIiEE, .-_Z6vectorSt6vectorIiSaIiEE
.weak pthread_mutex_unlock
.weak pthread_mutex_trylock
.weak pthread_mutex_lock
.weak pthread_create
.weak pthread_setspecific
.weak pthread_getspecific
.weak pthread_key_delete
.weak pthread_key_create
.weak pthread_once
.section .note.GNU-stack,"",@progbits
.ident "GCC: (GNU) 3.3.6 (Debian 1:3.3.6-5)"
The assembly code using at() instead of [] is much longer.
Cheers,
David
eviltwin69(a)cableone.net wrote:
I think you are all guessing.
I was under the impression that there was bounds checking going on with
vectors. Is this not the case?
Not necesserally: if you are using operator (), yes, if you use operator
[], no.
11:42 a.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
No, I am not. I cannot find the information on the C++
faq right now,
but If m pretty sure that it is written in the book of Stroustrup.
Of course, once I press the send button, I find the relevant webpage:
http://www.research.att.com/~bs/3rd_tour2.pdf (page 9 of the pdf)
"3.7.2 Range Checking
The standard library vector does not provide range checking by default
(§16.3.3).
[...]
The at() operation is a vector subscript operation that throws an
exception of type o ut _o f_ range if its argument is out of the v ec
to r's range (§16.3.3). """
11:58 a.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thu, Jun 09, 2005 at 10:31:35PM +0900, David Cournapeau wrote:
_Z6vectorSt6vectorIiSaIiEE:
.LFB539:
.L2:
.L7:
pushl %ebp
.LCFI0:
movl %esp, %ebp
.LCFI1:
popl %ebp
ret
you've been bitten by the optimizer, this function does
nothing but return (nothing). another hint to the fact that
c++ is superior ;)
<sk>
12:41 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On 6/9/05, stefan kersten <steve(a)k-hornz.de> wrote:
On Thu, Jun 09, 2005 at 10:31:35PM +0900, David
Cournapeau wrote:
Well, that's what happens when one post some code after some heavy
coding all day long, and when one tries to answer two questions at the
same time....That's why I would have prefered to find the relevant
part instead in the C++FAQ :)
Anyway, for the question "is there bound checking with operator[]",
the answer of Bjarne Stroustrup is no :).
The other problem "is [] as efficient for vector and plain c array
?", well, people who know better than me asm/gcc can test and answer.
Cheers,
David
_Z6vectorSt6vectorIiSaIiEE:
.LFB539:
.L2:
.L7:
pushl %ebp
.LCFI0:
movl %esp, %ebp
.LCFI1:
popl %ebp
ret
2:15 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thu, Jun 09, 2005 at 11:41:00PM +0900, David Cournapeau wrote:
The other problem "is [] as efficient for vector
and plain
c array ?"
possibly maybe:
#include <vector>
int access(int* v, int i)
{
return v[i];
}
int access(std::vector<int> v, int i)
{
return v[i];
}
produces (g++ -fverbose-asm -O3 -S):
_Z6accessPii:
pushl %ebp
movl %esp, %ebp
movl 12(%ebp), %ecx # i, i
movl 8(%ebp), %edx # v, v
popl %ebp
movl (%edx,%ecx,4), %eax # * v
ret
_Z6accessSt6vectorIiSaIiEEi:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %edx # v, this
movl 12(%ebp), %eax # i, i
popl %ebp
movl (%edx), %ecx # * this
sall $2, %eax
addl %ecx, %eax
movl (%eax), %eax
ret
on intel and
_Z6accessPii:
slwi 0,4,2 # i
lwzx 3,3,0 # * v, v
blr
_Z6accessSt6vectorIiSaIiEEi:
lwz 0,0(3) # * this
slwi 5,4,2 # i
lwzx 3,5,0 # this
blr
on ppc. note that on ppc the generated code is equivalent,
while on intel
movl (%edx,%ecx,4), %eax
might translate to a shift, add, fetch anyway. but probably
it's one of the 172 addressing modes.
basically, accessing std::vector needs one indirection more;
gcc should be smart enough (only verified on ppc) to hold
the actual array pointer in one of the numerous registers
when chaining accesses.
<sk>
4:39 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thu, 2005-06-09 at 18:14 +0200, stefan kersten wrote:
int access(std::vector<int> v, int i)
{
return v[i];
}
At least you are making copy here, should be
int access(std::vector<int> &v, int i)
--
Jussi Laako <jussi.laako(a)pp.inet.fi>
5:07 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thu, Jun 09, 2005 at 09:39:21PM +0300, Jussi Laako wrote:
On Thu, 2005-06-09 at 18:14 +0200, stefan kersten
wrote:
actually not, structs are passed by reference. operator[]
accesses a constant reference *(begin() + n) and the copy
constructor is not called. try it, the code generated is
exactly the same.
<sk>
int access(std::vector<int> v, int i)
{
return v[i];
}
At least you are making copy here, should be
int access(std::vector<int> &v, int i) 
5:21 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thursday 09 Jun 2005 20:07, stefan kersten wrote:
On Thu, Jun 09, 2005 at 09:39:21PM +0300, Jussi Laako
wrote:
$ cat a.cpp
#include <cassert>
struct A {
A() { }
A(const A &) { assert(0); }
};
void f(A) { }
int main(int argc, char **argv)
{
A a;
f(a);
}
$ gcc -O3 a.cpp -o a
$ ./a
a: a.cpp:5: A::A(const A&): Assertion `0' failed.
Aborted
$
On Thu, 2005-06-09 at 18:14 +0200, stefan kersten
wrote:
actually not, structs are passed by reference. int access(std::vector<int> v, int i)
At least you are making copy here, should be
int access(std::vector<int> &v, int i) 
6:04 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thu, Jun 09, 2005 at 08:23:57PM +0100, Chris Cannam wrote:
On Thursday 09 Jun 2005 20:07, stefan kersten wrote:
> On Thu, Jun 09, 2005 at 09:39:21PM +0300, Jussi Laako wrote:
> > On Thu, 2005-06-09 at 18:14 +0200, stefan kersten wrote:
> > > int access(std::vector<int> v, int i)
> >
> > At least you are making copy here, should be
> > int access(std::vector<int> &v, int i)
>
> actually not, structs are passed by reference.
[...]
a: a.cpp:5: A::A(const A&): Assertion `0'
failed.
Aborted
oh, you're right, i missed that. the struct is copied by the
caller, of course. doesn't change the code exmitted for
std::vector _access_, though.
<sk>
8:14 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thu, Jun 09, 2005 at 09:39:21PM +0300, Jussi Laako wrote:
No such problem with
int access(int *v, int i)
{
return v[i];
}
:-) :-) :-)
int
access(std::vector<int> v, int i)
{
return v[i];
}
At least you are making copy here, should be
int access(std::vector<int> &v, int i)
8:27 p.m.
New subject: [linux-audio-dev] [ot] [rant] gcc, you let me down one time toomany
On Thursday 09 Jun 2005 23:16, fons adriaensen wrote:
int access(int *v, int i)
{
return v[i];
}
Of course, passing that pointer by value is horribly inefficient.
int access(int *const &v, int i)
{
return v[i];
}
Chris
7103
days inactive
7103
days old
linux-audio-dev@lists.linuxaudio.org
16 comments
8 participants
participants (8)
-
Chris Cannam -
David Cournapeau -
Erik de Castro Lopo -
eviltwin69＠cableone.net -
fons adriaensen -
Jussi Laako -
Paul Davis -
stefan kersten