AMD opteron 64

Discussion in 'C Programming' started by Ben Pfaff, Dec 1, 2003.

  1. Ben Pfaff

    Ben Pfaff Guest

    Lionel Valero <> writes:

    > main (argc, argv)
    > int argc;
    > char *argv[];
    > {
    > int *ka;
    > int nka;
    >
    > /* allocation dynamique entiere */
    > ka = (int *) malloc(nka * sizeof(int));


    I don't recommend casting the return value of malloc():

    * The cast is not required in ANSI C.

    * Casting its return value can mask a failure to #include
    <stdlib.h>, which leads to undefined behavior.

    * If you cast to the wrong type by accident, odd failures can
    result.

    In fact, the second problem is your problem here. Fix it.

    When calling malloc(), I recommend using the sizeof operator on
    the object you are allocating, not on the type. For instance,
    *don't* write this:

    int *x = malloc (sizeof (int) * 128); /* Don't do this! */

    Instead, write it this way:

    int *x = malloc (sizeof *x * 128);

    There's a few reasons to do it this way:

    * If you ever change the type that `x' points to, it's not
    necessary to change the malloc() call as well.

    This is more of a problem in a large program, but it's still
    convenient in a small one.

    * Taking the size of an object makes writing the statement
    less error-prone. You can verify that the sizeof syntax is
    correct without having to look at the declaration.

    --
    char a[]="\n .CJacehknorstu";int putchar(int);int main(void){unsigned long b[]
    ={0x67dffdff,0x9aa9aa6a,0xa77ffda9,0x7da6aa6a,0xa67f6aaa,0xaa9aa9f6,0x1f6},*p=
    b,x,i=24;for(;p+=!*p;*p/=4)switch(x=*p&3)case 0:{return 0;for(p--;i--;i--)case
    2:{i++;if(1)break;else default:continue;if(0)case 1:putchar(a[i&15]);break;}}}
     
    Ben Pfaff, Dec 1, 2003
    #1
    1. Advertising

  2. Hello,

    I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
    ***********************
    main (argc, argv)
    int argc;
    char *argv[];
    {
    int *ka;
    int nka;

    /* allocation dynamique entiere */
    ka = (int *) malloc(nka * sizeof(int));
    if (!ka) {
    printf ("<ERROR> : Out of heap space (malloc) !\n");
    printf ("<ERROR> : %d int words required\n", nka);
    exit (-1);
    }
    }
    ***********************

    But under linux suse AMD opteron 64, i get this message from the compiler :

    warning: cast to pointer from integer of different size

    Any explanation ?

    Regards,
    Lionel.
    --
    -=O=------------------------------------------=O=-
    Lionel Valéro
    Analyste Informatique Département Génie Chimique
    École Polytechnique de Montréal
    C.P. 6079, succ. centre-ville
    Montréal (Québec) H3C 3A7
    Tel: (514) 340 - 4711 # 4805 / C552
    Fax: (514) 340 - 4159
    -=O=------------------------------------------=O=-
     
    Lionel Valero, Dec 1, 2003
    #2
    1. Advertising

  3. Ben Pfaff

    Randy Howard Guest

    In article <nELyb.74495$>,
    says...
    > Hello,
    >
    > I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
    > ***********************
    > main (argc, argv)
    > int argc;
    > char *argv[];
    > {
    > int *ka;
    > int nka;
    >
    > /* allocation dynamique entiere */
    > ka = (int *) malloc(nka * sizeof(int));
    > if (!ka) {
    > printf ("<ERROR> : Out of heap space (malloc) !\n");
    > printf ("<ERROR> : %d int words required\n", nka);
    > exit (-1);
    > }
    > }
    > ***********************
    >
    > But under linux suse AMD opteron 64, i get this message from the compiler :
    >
    > warning: cast to pointer from integer of different size
    >
    > Any explanation ?


    At a quick glance, you seem to have left out a proper header for malloc.
    The compiler doesn't automagically know what "malloc" means without one.
    Also, the cast is not required in C, and helps to hide this omission from
    you, thereby making it harder to diagnose.

    --
    Randy Howard _o
    2reply remove FOOBAR \<,
    ______________________()/ ()______________________________________________
    SCO Spam-magnet:
     
    Randy Howard, Dec 1, 2003
    #3
  4. Ben Pfaff

    SenderX Guest

    > ka = (int *) malloc(nka * sizeof(int));

    No cast.

    Also, sizeof( void* ) might not equal sizeof( int* ).

    --
    The designer of the experimental, SMP and HyperThread friendly, AppCore
    library.

    http://AppCore.home.comcast.net
     
    SenderX, Dec 1, 2003
    #4
  5. Ben Pfaff

    Lew Pitcher Guest

    On Mon, 01 Dec 2003 18:21:07 GMT, Lionel Valero <>
    wrote:

    >Hello,
    >
    >I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
    >***********************
    >main (argc, argv)
    > int argc;
    > char *argv[];
    >{
    > int *ka;
    > int nka;
    >
    > /* allocation dynamique entiere */
    > ka = (int *) malloc(nka * sizeof(int));
    > if (!ka) {
    > printf ("<ERROR> : Out of heap space (malloc) !\n");
    > printf ("<ERROR> : %d int words required\n", nka);
    > exit (-1);
    > }
    >}
    >***********************
    >
    >But under linux suse AMD opteron 64, i get this message from the compiler :
    >
    >warning: cast to pointer from integer of different size
    >
    >Any explanation ?


    Yes. You neglected to
    #include <stdlib.h>
    which defines the malloc() function's return value.

    Since you did not do this, the compiler assumed that malloc() returned the
    default type (int), and saw that you forced a conversion from (int) to (int *)
    in your code. The compiler issued the warning based on this.

    The fix is to
    a) include <stdlib.h> in your code, and
    b) remove the unnecessary case of malloc()'s return value.

    --
    Lew Pitcher
    IT Consultant, Enterprise Technology Solutions
    Toronto Dominion Bank Financial Group

    (Opinions expressed are my own, not my employers')
     
    Lew Pitcher, Dec 1, 2003
    #5
  6. I forgto the headers :
    #include <stdio.h>
    #include <sys/types.h>
    #include <time.h>


    Lionel Valero wrote:

    > Hello,
    >
    > I have a test program that is compiled fine on a 32 bits redhat linux
    > using gcc :
    > ***********************
    > main (argc, argv)
    > int argc;
    > char *argv[];
    > {
    > int *ka;
    > int nka;
    >
    > /* allocation dynamique entiere */
    > ka = (int *) malloc(nka * sizeof(int));
    > if (!ka) {
    > printf ("<ERROR> : Out of heap space (malloc) !\n");
    > printf ("<ERROR> : %d int words required\n", nka);
    > exit (-1);
    > }
    > }
    > ***********************
    >
    > But under linux suse AMD opteron 64, i get this message from the compiler :
    >
    > warning: cast to pointer from integer of different size
    >
    > Any explanation ?
    >
    > Regards,
    > Lionel.


    --
    -=O=------------------------------------------=O=-
    Lionel Valéro
    Analyste Informatique Département Génie Chimique
    École Polytechnique de Montréal
    C.P. 6079, succ. centre-ville
    Montréal (Québec) H3C 3A7
    Tel: (514) 340 - 4711 # 4805 / C552
    Fax: (514) 340 - 4159
    -=O=------------------------------------------=O=-
     
    Lionel Valero, Dec 1, 2003
    #6
  7. Ben Pfaff

    Randy Howard Guest

    In article <6dMyb.74810$>,
    says...
    > I forgto the headers :
    > #include <stdio.h>
    > #include <sys/types.h>
    > #include <time.h>


    <sys/types.h> does not seem to be necessary for what you have below
    and you will find out that it isn't portable either.

    <time.h> also does not seem to be necessary, but at least is standard.

    What is necessary: <stdlib.h>, as has been pointed out already in this
    thread.

    >
    >
    > Lionel Valero wrote:
    >
    > > Hello,
    > >
    > > I have a test program that is compiled fine on a 32 bits redhat linux
    > > using gcc :
    > > ***********************
    > > main (argc, argv)
    > > int argc;
    > > char *argv[];
    > > {
    > > int *ka;
    > > int nka;
    > >
    > > /* allocation dynamique entiere */
    > > ka = (int *) malloc(nka * sizeof(int));
    > > if (!ka) {
    > > printf ("<ERROR> : Out of heap space (malloc) !\n");
    > > printf ("<ERROR> : %d int words required\n", nka);
    > > exit (-1);
    > > }
    > > }
    > > ***********************
    > >
    > > But under linux suse AMD opteron 64, i get this message from the compiler :
    > >
    > > warning: cast to pointer from integer of different size
    > >
    > > Any explanation ?
    > >
    > > Regards,
    > > Lionel.

    >
    >


    --
    Randy Howard _o
    2reply remove FOOBAR \<,
    ______________________()/ ()______________________________________________
    SCO Spam-magnet:
     
    Randy Howard, Dec 1, 2003
    #7
  8. Lionel Valero wrote:

    > I have a test program
    > that is compiled fine on a 32 bits redhat linux using gcc :
    > ***************


    > cat malloc.c

    #include <stdlib.h>
    #include <stdio.h>

    int main (int argc, char* argv[]) {
    int nka = atoi(argv[1]);

    /* allocation dynamique entiere */
    int* ka = (int*)malloc(nka*sizeof(int));
    if (NULL == ka) {
    fprintf(stderr, "<ERROR>: Out of free storage (malloc)!\n");
    fprintf(stderr, "<ERROR>: %d int words required\n", nka);
    exit (EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
    }

    > gcc -Wall -std=c99 -pedantic -o malloc malloc.c
    > ./malloc 13
    > ./malloc 999999999999

    <ERROR>: Out of free storage (malloc)!
    <ERROR>: 2147483647 int words required

    > ***********************
    >
    > But under linux suse AMD opteron 64, I get this message from the compiler:
    >
    > warning: cast to pointer from integer of different size
    >
    > Any explanation?


    You need to include stdlib.h which declares malloc.
     
    E. Robert Tisdale, Dec 1, 2003
    #8
  9. Ben Pfaff wrote:

    > I don't recommend casting the return value of malloc():
    >
    > * The cast is not required in ANSI C.


    But an ANSI/ISO C++ compiler will complain.

    > * Casting its return value can mask a failure to
    > #include <stdlib.h>, which leads to undefined behavior.


    No! It may mask the fact that malloc was not declared
    but a good C compiler will warn you about that.

    > * If you cast to the wrong type by accident,
    > odd failures can result.


    Can you show us an example?

    > In fact, the second problem is your problem here. Fix it.
    >
    > When calling malloc(), I recommend using the sizeof operator on
    > the object you are allocating, not on the type. For instance,
    > *don't* write this:
    >
    > int *p = malloc (sizeof (int) * 128); /* Don't do this! */
    >
    > Instead, write it this way:
    >
    > int *p = malloc (sizeof *p * 128);
    >
    > There's a few reasons to do it this way:
    >
    > * If you ever change the type that `p' points to, it's not
    > necessary to change the malloc() call as well.


    A better solution would be:

    typedef int T;
    T* p = (T*)malloc(128*sizeof(T));

    > This is more of a problem in a large program
    > but it's still convenient in a small one.
    >
    > * Taking the size of an object makes writing the statement
    > less error-prone. You can verify that the sizeof syntax is
    > correct without having to look at the declaration.
     
    E. Robert Tisdale, Dec 1, 2003
    #9
  10. On Mon, 1 Dec 2003 19:00:18 UTC, Lionel Valero
    <> wrote:

    > I forgto the headers :
    > #include <stdio.h>
    > #include <sys/types.h>
    > #include <time.h>
    >


    You forgot to include stdlib.h again
    > Lionel Valero wrote:


    > > ka = (int *) malloc(nka * sizeof(int));


    And this cast hides the error that you forgot to include the header in
    redhat linux.
    Casting the result from a function that returns void* is always an
    error.

    --
    Tschau/Bye
    Herbert

    To buy eComStation 1.1 in germany visit http://www.pc-rosenau.de
     
    The Real OS/2 Guy, Dec 1, 2003
    #10
  11. Ben Pfaff

    Ben Pfaff Guest

    "E. Robert Tisdale" <> writes:

    > Ben Pfaff wrote:
    >
    > > I don't recommend casting the return value of malloc():
    > > * The cast is not required in ANSI C.

    >
    > But an ANSI/ISO C++ compiler will complain.


    Fortunately, we are not discussing C++. malloc() should not
    normally be used in C++.

    > > * Casting its return value can mask a failure to
    > > #include <stdlib.h>, which leads to undefined behavior.

    >
    > No! It may mask the fact that malloc was not declared
    > but a good C compiler will warn you about that.


    This is in fact the OP's problem, so I don't see how you can
    discount it.

    > > * If you cast to the wrong type by accident,
    > > odd failures can result.

    >
    > Can you show us an example?


    Casting to (char) instead of (char *) is bound to be a problem.

    > > In fact, the second problem is your problem here. Fix it.
    > > When calling malloc(), I recommend using the sizeof operator on
    > > the object you are allocating, not on the type. For instance,
    > > *don't* write this:
    > > int *p = malloc (sizeof (int) * 128); /* Don't do this! */
    > > Instead, write it this way:
    > > int *p = malloc (sizeof *p * 128);
    > > There's a few reasons to do it this way:
    > > * If you ever change the type that `p' points to, it's not
    > > necessary to change the malloc() call as well.

    >
    > A better solution would be:
    >
    > typedef int T;
    > T* p = (T*)malloc(128*sizeof(T));


    I don't see how that's a better solution at all.
    --
    int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.\
    \n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
    );while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p\
    );}return 0;}
     
    Ben Pfaff, Dec 1, 2003
    #11
  12. Ben Pfaff

    Mike Wahler Guest

    "E. Robert Tisdale" <> wrote in message
    news:...
    > Ben Pfaff wrote:
    >
    > > I don't recommend casting the return value of malloc():
    > >
    > > * The cast is not required in ANSI C.

    >
    > But an ANSI/ISO C++ compiler will complain.


    So what? This is comp.lang.c.


    >
    > > * Casting its return value can mask a failure to
    > > #include <stdlib.h>, which leads to undefined behavior.

    >
    > No! It may mask the fact that malloc was not declared
    > but a good C compiler will warn you about that.


    It might, but it's not required to. I'd rather rely upon
    accurate knowledge than depend upon a convenience feature
    of a tool, which might or might not exist.

    >
    > > * If you cast to the wrong type by accident,
    > > odd failures can result.

    >
    > Can you show us an example?


    The OP's original message is a perfect example.

    >
    > > In fact, the second problem is your problem here. Fix it.
    > >
    > > When calling malloc(), I recommend using the sizeof operator on
    > > the object you are allocating, not on the type. For instance,
    > > *don't* write this:
    > >
    > > int *p = malloc (sizeof (int) * 128); /* Don't do this! */
    > >
    > > Instead, write it this way:
    > >
    > > int *p = malloc (sizeof *p * 128);
    > >
    > > There's a few reasons to do it this way:
    > >
    > > * If you ever change the type that `p' points to, it's not
    > > necessary to change the malloc() call as well.

    >
    > A better solution would be:
    >
    > typedef int T;
    > T* p = (T*)malloc(128*sizeof(T));


    Casting the return value from malloc() is never 'better'.
    And your typdef only obfuscates things.


    -Mike
     
    Mike Wahler, Dec 1, 2003
    #12
  13. Ben Pfaff

    Eric Sosman Guest

    "E. Robert Tisdale" wrote:
    >
    > Ben Pfaff wrote:
    >
    > > I don't recommend casting the return value of malloc():
    > >
    > > * The cast is not required in ANSI C.

    >
    > But an ANSI/ISO C++ compiler will complain.


    A COBOL compiler will complain even louder. So what?

    --
     
    Eric Sosman, Dec 1, 2003
    #13
  14. On Mon, 01 Dec 2003 18:21:07 GMT, in comp.lang.c , Lionel Valero
    <> wrote:

    >Hello,
    >
    >I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
    >***********************
    >main (argc, argv)
    > int argc;
    > char *argv[];
    >{
    > int *ka;
    > int nka;
    >
    > /* allocation dynamique entiere */
    > ka = (int *) malloc(nka * sizeof(int));


    Everyone else has explained your immediate problem.forgetting

    HoweverI notice you are using nka to size your array. But you didn't
    initialise it to any value. So it contains garbage, and may crash your
    program.

    --
    Mark McIntyre
    CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
    CLC readme: <http://www.angelfire.com/ms3/bchambless0/welcome_to_clc.html>


    ----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
    http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
    ---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---
     
    Mark McIntyre, Dec 1, 2003
    #14
  15. Eric Sosman <> scribbled the following:
    > "E. Robert Tisdale" wrote:
    >> Ben Pfaff wrote:
    >> > I don't recommend casting the return value of malloc():
    >> >
    >> > * The cast is not required in ANSI C.

    >>
    >> But an ANSI/ISO C++ compiler will complain.


    > A COBOL compiler will complain even louder. So what?


    ERT seems to have a fascination with compiling C code with a C++
    compiler these days. Can you say "one-trick pony", ERT?

    --
    /-- Joona Palaste () ------------- Finland --------\
    \-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
     
    Joona I Palaste, Dec 1, 2003
    #15
  16. Ben Pfaff

    Jack Klein Guest

    On Mon, 01 Dec 2003 13:07:09 -0800, "E. Robert Tisdale"
    <> wrote in comp.lang.c:

    > Lionel Valero wrote:
    >
    > > I have a test program
    > > that is compiled fine on a 32 bits redhat linux using gcc :
    > > ***************


    Still playing the fool I see, Tisdale.

    > > cat malloc.c

    > #include <stdlib.h>
    > #include <stdio.h>
    >
    > int main (int argc, char* argv[]) {
    > int nka = atoi(argv[1]);


    What happens when you run it without command line arguments and
    dereference the null pointer? Can you say "segfault"?

    > /* allocation dynamique entiere */
    > int* ka = (int*)malloc(nka*sizeof(int));


    About one in 20 times you actually post something of value. Sadly,
    this is not one of those times...

    int *ka = malloc(nka * sizeof *ka);

    Note the pleasing symmetry of the dual asterisks.

    > if (NULL == ka) {
    > fprintf(stderr, "<ERROR>: Out of free storage (malloc)!\n");
    > fprintf(stderr, "<ERROR>: %d int words required\n", nka);
    > exit (EXIT_FAILURE);
    > }
    > return EXIT_SUCCESS;
    > }
    >
    > > gcc -Wall -std=c99 -pedantic -o malloc malloc.c
    > > ./malloc 13
    > > ./malloc 999999999999

    > <ERROR>: Out of free storage (malloc)!
    > <ERROR>: 2147483647 int words required


    Why didn't you show the results of running:

    ./malloc

    ???

    --
    Jack Klein
    Home: http://JK-Technology.Com
    FAQs for
    comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
    comp.lang.c++ http://www.parashift.com/c -faq-lite/
    alt.comp.lang.learn.c-c++ ftp://snurse-l.org/pub/acllc-c /faq
     
    Jack Klein, Dec 2, 2003
    #16
  17. Ben Pfaff

    CBFalconer Guest

    *** topposting fixed ***

    Lionel Valero wrote:
    > Lionel Valero wrote:
    >
    > > I have a test program that is compiled fine on a 32 bits redhat linux
    > > using gcc :
    > > ***********************
    > > main (argc, argv)
    > > int argc;
    > > char *argv[];


    Do not use old fashioned function declarations, they have been
    obsolete for at least 15 years. main returns int, say so.

    > > {
    > > int *ka;
    > > int nka;
    > >
    > > /* allocation dynamique entiere */
    > > ka = (int *) malloc(nka * sizeof(int));


    Do not cast malloc results. nka is uninitialized. Use sizeof
    *ka.

    > > if (!ka) {
    > > printf ("<ERROR> : Out of heap space (malloc) !\n");
    > > printf ("<ERROR> : %d int words required\n", nka);
    > > exit (-1);


    -1 is not a portable value here. EXIT_FAILURE and
    EXIT_SUCCESS come to mind, after #including <stdlib.h>

    > > }
    > > }
    > > ***********************
    > >
    > > But under linux suse AMD opteron 64, i get this message from the compiler :
    > >
    > > warning: cast to pointer from integer of different size
    > >
    > > Any explanation ?


    Increase the gcc warning levels. -W -Wall -ansi -pedantic -O1 are
    the recommended minimum.

    >
    > I forgto the headers :
    > #include <stdio.h>
    > #include <sys/types.h>


    This is not a valid ISO C header. Omit it.

    > #include <time.h>


    This is not used. omit it.

    Please Do Not Toppost.

    --
    Chuck F () ()
    Available for consulting/temporary embedded and systems.
    <http://cbfalconer.home.att.net> USE worldnet address!
     
    CBFalconer, Dec 2, 2003
    #17
  18. "E. Robert Tisdale" <> writes:
    > Ben Pfaff wrote:
    > > I don't recommend casting the return value of malloc():
    > > * The cast is not required in ANSI C.

    >
    > But an ANSI/ISO C++ compiler will complain.


    So don't use a C++ compiler on C source (or a Fortran compiler, or an
    Intercal compiler). There's no good reason C source code should be
    constrained to be valid C++.

    <OT>
    Well-written C++ code doesn't use malloc() anyway; it uses the "new"
    operator.
    </OT>

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://www.sdsc.edu/~kst>
    Schroedinger does Shakespeare: "To be *and* not to be"
    (Note new e-mail address)
     
    Keith Thompson, Dec 2, 2003
    #18
  19. On Mon, 01 Dec 2003 13:20:48 -0800, "E. Robert Tisdale"
    <> wrote:

    >Ben Pfaff wrote:
    >
    >> I don't recommend casting the return value of malloc():
    >>
    >> * The cast is not required in ANSI C.

    >
    >But an ANSI/ISO C++ compiler will complain.
    >
    >> * Casting its return value can mask a failure to
    >> #include <stdlib.h>, which leads to undefined behavior.

    >
    >No! It may mask the fact that malloc was not declared
    >but a good C compiler will warn you about that.


    On a machine where the method of returning a pointer differs from the
    method of returning an int (such as using a different register), the
    behavior is indeed undefined. malloc will return the pointer using
    the correct procedure. The compiler will generate code to convert the
    assumed returned int. Since malloc did not return an int, this code
    will operate on residual data.


    <<Remove the del for email>>
     
    Barry Schwarz, Dec 2, 2003
    #19
  20. Ben Pfaff

    Richard Bos Guest

    Joona I Palaste <> wrote:

    > Eric Sosman <> scribbled the following:
    > > "E. Robert Tisdale" wrote:
    > >> Ben Pfaff wrote:
    > >> > I don't recommend casting the return value of malloc():
    > >> >
    > >> > * The cast is not required in ANSI C.
    > >>
    > >> But an ANSI/ISO C++ compiler will complain.


    Which proves once again that C++ is broken, since the cast is useless
    and useless casts should be anathema.

    > > A COBOL compiler will complain even louder. So what?

    >
    > ERT seems to have a fascination with compiling C code with a C++
    > compiler these days.


    That's because ERT has, and AFAICT has always had, a bee in his bonnet
    about C++ being "the new C". Not even Bjarne Stroustrup has that
    delusion, but some people are impossible to disconfuse.

    Richard
     
    Richard Bos, Dec 2, 2003
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Dan
    Replies:
    2
    Views:
    555
  2. js
    Replies:
    0
    Views:
    1,222
  3. Andy
    Replies:
    5
    Views:
    2,831
  4. Rajrup Banerjee

    SGI STL Library on Opteron

    Rajrup Banerjee, May 21, 2004, in forum: C++
    Replies:
    1
    Views:
    313
    Christopher Benson-Manica
    May 21, 2004
  5. Replies:
    1
    Views:
    351
    Larry Bates
    Oct 26, 2005
Loading...

Share This Page