Reprise du message précédent :
Grosse blague : on a (enfin) un IDE valable sur notre servuer.  
SunStudio8. Super bien. Ouaipmsieur. Ecrit tout en Java.
 
Donc, j'ai :  
- un bon éditeur (mais moins bon que nEdit, genre pas de search&replace en PCRE)
- un front-end à DBX intégré (par contre bien fait et sympathoche)
- et tout ce qui va bien dans un IDE de base.
 
Juste, donc, c'est écrit en Java.
 
Et donc, c'est megalent. Inutilisable, en fait.
 
J'vais juste l'utiliser pour le debugger en fait.

C'est marrant que tu dises ça, on vient juste de passer à sun-studio 11 et tout le monde est excité. Juste au moment où j'ai enfin pris 5 minutes pour coder un Imakefile->vcproj.
 
Mais je continue à trouver ça moche et lent.  

moche on s'en fout, si c'est fonctionnel
 
Par contre c'est leeeeeeeeeeent à mourir, je vois pas comment on peut décemment programmer quoique ce soit avec cet IDE.

 
Il faudra un jour obliger les développeurs d'IDE à bosser tous les jours avec leurs IDE, ça évitera les problèmes

c'est contre eclipse que tu dis ça ?
 
eux ils s'en foutent les mecs d'éclipse, comme ils font de l'opensource, ils ont des licences intellij gratos

Quand je dis moche, je parle de la qualité des fontes, de l'ergonomie de l'IHM, et de la convivialité de l'ensemble, dans l'optique de bosser 8h/j avec. Je te parle pas du choix de la couleur de l'icone de sunstudio...

void dvg_buildtextures
(void)
{
    const size_t size=64;
    size_t i, j, tmp=0;
    /* Build circular gradient*/
    dvg.textures[DVG_TEX_CIRCULAR].data = malloc(size*size*2);
    for (i=0; i<size; i+=2) {
        for (j=0; j<=i; j+=2) {
            /* profit from 4-axis symetry and assign both luminance and alpha */
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+i)*size+j] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+i)*size+j+1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+i)*size-j-2] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+i)*size-j-1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-i)*size+j] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-i)*size+j+1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-i)*size-j-2] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-i)*size-j-1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+j)*size+i] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+j)*size+i+1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+j)*size-i-2] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size+1+j)*size-i-1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-j)*size+i] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-j)*size+i+1] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-j)*size-i-2] = tmp;
            dvg.textures[DVG_TEX_CIRCULAR].data[(size-1-j)*size-i-1] = tmp;
            /* calculate only forward difference */
            tmp += (8*j+4)/size;
        }
        tmp = i*i*2/size;
    }
    glGenTextures(1, &dvg.textures[DVG_TEX_CIRCULAR].id);
    glBindTexture(GL_TEXTURE_2D, dvg.textures[DVG_TEX_CIRCULAR].id);
    glTexImage2D(GL_TEXTURE_2D, 0, 2, size, size, 0, GL_LUMINANCE_ALPHA,
                 GL_UNSIGNED_BYTE, dvg.textures[DVG_TEX_CIRCULAR].data);
}

c'est typiquement le genre de truc sur lequel tu gagnes +60% de perfs en utilisant le MMX

recherche un obfuscateur de code C#, y'en a des pas mal
sinon, tu peux aussi coder ton appli en MSIL direct

 
deja jviens de passer le tableau en short int plutot que char pour assigner 2 cases consécutives en même temps ( vu qu'elles sont identiques ) :

void dvg_buildtextures
(void)
{
    const size_t size=64, hsize=size/2;
    size_t i, j;
    unsigned char tmp=0;
    unsigned short tmp2=0, *arr;
    /* Build dynamic circular gradient - here be dragons */
    dvg.textures[DVG_TEX_CIRCULAR].data = malloc(size*size*2);
    arr = (void*)(dvg.textures[DVG_TEX_CIRCULAR].data);
    for (i=0; i<hsize; i++) {
        for (j=0; j<=i; j++) {
            /* profit from 4-axis symetry and assign both luminance and alpha */
            arr[(hsize+i)*size+hsize+j] = tmp2;
            arr[(hsize+i)*size+hsize-j-1] = tmp2;
            arr[(hsize-i)*size-hsize+j] = tmp2;
            arr[(hsize-i)*size-hsize-j-1] = tmp2;
            arr[(hsize+j)*size+hsize+i] = tmp2;    
            arr[(hsize+j)*size+hsize-i-1] = tmp2;
            arr[(hsize-j)*size-hsize+i] = tmp2;
            arr[(hsize-j)*size-hsize-i-1] = tmp2;
            /* calculate only forward difference */
            tmp = (16*j+4)/size;
            tmp2 += tmp | (tmp<<8);
        }
        tmp = i*i*8/size;
        tmp2 = tmp | (tmp<<8);
    }
    glGenTextures(1, &dvg.textures[DVG_TEX_CIRCULAR].id);
    glBindTexture(GL_TEXTURE_2D, dvg.textures[DVG_TEX_CIRCULAR].id);
    glTexImage2D(GL_TEXTURE_2D, 0, 2, size, size, 0, GL_LUMINANCE_ALPHA,
                 GL_UNSIGNED_BYTE, dvg.textures[DVG_TEX_CIRCULAR].data);
}

 
mais voui du MMX ca ferait pas de mal surement...

avec un --fontsize 14 ça passait pas mal du tout, par contre la font taille 6 de base c'est d'une stupidité sans nom.
 
Quant au reste j'ai pas pu juger, vu que ça prend plusieurs secondes de naviguer dans un menu pour activer une sous-fenêtre

j'espere que c'est pas pour l'ecole  

j'ai pas besoin d'obfuscateur moi, je code tellement cradement que mon code est illisible au naturel
sinon y'a dotfuscator qui est pas mal

 
Et c'est si grave que ça que les gens aient accès à ton code ? (ne vois pas d'agressivité dans ma question)

arr[(hsize+i)*size+hsize+j] = tmp2;
            arr[(hsize+i)*size+hsize-j-1] = tmp2;
            arr[(hsize-i)*size-hsize+j] = tmp2;
            arr[(hsize-i)*size-hsize-j-1] = tmp2;
            arr[(hsize+j)*size+hsize+i] = tmp2;    
            arr[(hsize+j)*size+hsize-i-1] = tmp2;
            arr[(hsize-j)*size-hsize+i] = tmp2;
            arr[(hsize-j)*size-hsize-i-1] = tmp2;

Et si on commencait par calculer une seule fois hsize*size, et i*size ?
 
k = hsize*size
isize = i*size
jsize= j*size
 
 arr[k+isize+hsize+j] = tmp2;
 arr[k+isize+hsize-j-1] = tmp2;
 arr[k-isize-hsize+j] = tmp2;
 arr[k-isize-hsize-j-1] = tmp2;
 arr[k+jsize+hsize+i] = tmp2;  
 arr[k+jsize+hsize-i-1] = tmp2;
 arr[k-jsize-hsize+i] = tmp2;
 arr[k-jsize-hsize-i-1] = tmp2;
 

Les maths de 6ème c'est surpuissant

retourne le probleme
 
Imgaine qqun qui accede aux codes d'harko et qui apprend a programmer a partir de ça    
 

ah voui, chuis une quiche, j'aurais pu continuer encore...
Cela dit, jme demande si ca aura un réel effet, il me semble que les sous-parties communes des expressions arithmétiques sont unifiées par gcc dans ce genre de cas.

fous du MMX la d'dans bordel, tu pourras traiter 4 ou 8 pixels en une seule fois

j'eus aimé savoir faire, à une époque.

 
ouais mais le code va s'allonger et jvais perdre en portabilité.

Comment ?  
C'est un vrai gruyere son truc.

y'a des processeurs sans mmx aujourd'hui ?

Oui plein, surtout sur des machines avec l'openGL
( nan ouais, en fait ca limite pas vraiment la portabilité au niveau du mmx, mais par contre il me semble qu'au niveau différentes syntaxes pour insérer l'assembleur c'est le bordel )

Tiens, il y a des pubs pour suse sur /.
Linux, ça c'est quand même vachement élargi comme userbase:
http://gfx.klipmart.com/klipmart/c [...] 8445172000

Rien que les PowerPC.
 
Mais plein d'autres aussi, les Niagara & Niagara II de Sun, les Alpha, les ARM, PA-RISC, S/390, ...
 
En fait tu prends toutes les architectures sur lesquelles tournent OpenBSD et Debian, tu enlèves x86 (i386/i686/amd64) et tu as la liste.

Ok, donc ceux qui n'ont pas de MMX sont ceux utilisés par personne ?

J'ai fini à 180 contre -54 !
 

wala, à peu près.

 
Par ceux qui lisent des mp3 avec une interface en curses

C'était pas la peine d'éditer pour poster la version hi-res, on s'en tape

vivement le prochain edit en 2048*1600  
 
florentG mange ton Kakhä

En fait, en y repensant, le fait que le mmx pourrisse les flottants et force un super-temps de latence just après et que le code soit tartinée de flottants partout (opengl quoi), ca risque pas de me faire perdre ce que j'aurais pu gagner en les utilisant ?

2880 * 1600 /\

Est-ce synonyme de grilled ?

Les mainframes et les serveurs, sauf qu'aux dernières nouvelles 0x90 n'a pas dit ce à quoi son truc allait servir et où il allait être utilisé, de plus il se soucie de la portabilité, donc ce genre de points peut être important

 
Un projet minable d'etudiant en info qui va tourner sur 3 machines

dernier jour de ma mission Web2.0 qui roxxe sa maman en slip qui suce des ours.....Faiche!
 
 
MAIS EMBAUCHEZ MOI A UN SALAIRE RAISONNABLE? BANDE DE MOULES! /FOU/

Sinon niveau libido ça va depuis que ta femme a expulsé un placenta ?

 
Il touche plus les bords

 
mais va te faire cuire le cul, toi!  

ça a l'air sympa le télétravail