Waldorf en faillite

Citation : Il en manque

Citation :
Ce qui pourrait être plus drôle, avec l'avènement des derniers DSPs et des FPGAs, c'est de voir lequel tournerait le mieux... Avec un DSP capable de mettre le plus gros Pentium dans le vent, un synthé hard serait largement meilleur - je pense justement à Analog Devices avec leur Shark et plus dernièrement le Blackfin -, mais quand on utilise en parallèle 3 DSPs, on peut se dire que le FPGA, c'est pas mal aussi... Evolutivité, SIMD massif,

Citation : ça fait tout simplement deux fois qu'ils se plantent, pas mal, à quand la troisième?

Citation :
Avec la différence que tout ce qu'un PC peut faire, les procs dédiés peuvent le faire qqs mois plus tard...

Citation :
Le dernier de chez TI à GHz avec multiplication en 1 coup d'horologe, ça te fait plus que ça sans pb...

Citation :
Tu m'étonnes, il devient RISC, le petit, et pique tout ce qui a fait que les autres procs étaient plus rapides...

Citation :
"Today [in RISC] we have large design teams and long design cycles," he said. "The performance story is also much less clear now. The die sizes are no longer small. It just doesn't seem to make as much sense." The result is the current crop of complex RISC chips. "Superscalar and out-of-order execution are the biggest problem areas that have impeded performance [leaps]," Ditzel said. "The MIPS R10,000 and HP PA-8000 seem much more complex to me than today's standard CISC architecture, which is the Pentium II. So where is the advantage of RISC, if the chips aren't as simple anymore?"

Citation :
We now live in a "post-RISC" world, where the terms RISC and CISC have lost their relevance (except to marketing departments and platform advocates). In a post-RISC world, each architecture and implementation must be judged on its own merits, and not in terms of a narrow, bipolar, compartmentalized worldview that tries to cram all designs into one of two "camps."

Citation :
Juste pour mettre mon grain de sel;
puissance procs vs algorithmique: mon frangin fait de la physique théorique (quantique), et en ce moment l'option est plutot de revoir tous les algos et en trouver d'autres, car le gain est bien bien plus important que ce qu'apportent les différentes générations de processeurs (on parle là de supercalculateurs, qui coute trés chers, et dont le CPU est souvent facturé à la seconde).

Hors sujet : Si vous comprenez quelque chose à ce débat, ne prenez pas la route.

Citation :
En revanche, avec des optimisations, le DSP aurait réussi - d'ailleurs, ne mélange pas DSP et ARM stp, c'est PAS DU TOUT la même chose -

Citation :
De plus, les compilateurs fournis permettent de se passer de l'assembleur, tout peut être fait en C ou C++ avec peu d'overhead.

Citation :
Donc les libs de PC sont utilisables...

Citation :
RISC, c'est pas pour rendre les puces plus simples, au contraire, dès le départ avec le séquenceur câblé, au savait que c'était plus compliqué

Citation : Tiens, je veux bien voir tes exemples de codage

Citation :
#include <iostream>
#include <math.h>

#include "cycle.h"

inline void f1(const float* lx, const float* ly,
float* lz, const int size)
{
int i = 0;

for (i = 0; i < size; ++i)
{
lz[i] += lx[i] * ly[i];
}
}

void app_hann(float* &h ,unsigned int N)
{
if ( N < 1 )
{
std::cerr << "N must be equal or greater than 1n";
exit(1);
}

// Initialisation :
// - s : is for sin calculation
// - c : c is for cos.
//
// Last and curr var are used to compute sin and cos ( cf Numerical
// recipes in C, chap 5.5. )

float s_last = 0;
float s_curr = 0;
float c_last = 1.0;
float c_curr = 0;
float alpha = 0.1;
float beta = 0.2;
float delta = 3.14159/N;

//alpha = 2*(sin(delta)*sin(delta));
//beta = sin(2*delta);

//h = new float[N];
h[0] = 0;

for ( int loop = 1 ; loop < N ; ++loop)
{
// First the alpha*cos(teta)+beta*sin(teta) is computed
// This operation MUST be done at the begining.

c_curr = (-1) * alpha * c_last + (-1) * beta * s_last;
s_curr = (-1) * alpha * s_last + beta * c_last;

// computation of the actual windows coefficients

c_curr += c_last;
s_curr += s_last;

h[loop] = 0.5-0.5*c_curr;

// New values of c_last and s_last

c_last = c_curr;
s_last = s_curr;
}
}

int main()
{
ticks t0, t1;

float *x, *y, *z;
const int N = 1024;
const int Nloop = 16;

x = new float[N];
y = new float[N];
z = new float[N];

double result;

for (int loop = 0; loop < N; ++loop)
{
// convert to float to have float division instead of
// euclidian division !
x[loop] = (float)loop/N;
y[loop] = -(float)loop/N;
}

// f1, pass 1
t0 = getticks();

for (int loop = 0; loop < Nloop; ++loop)
{
f1(x, y, z, N);
}

t1 = getticks();

double result1 = elapsed(t1, t0);

std::cout << "ticks for f1, pass 1 is around : " << result1/Nloop << std::endl;

// f2, pass 1
t0 = getticks();

for (int loop = 0; loop < Nloop; ++loop)
{
//N * 8
app_hann( z, N);
}

t1 = getticks();

double result2 = elapsed(t1, t0);

std::cout << "ticks for f2, pass 1 is around : " << result2/Nloop << std::endl;
std::cout << "For this number of cycles, there is : n"
<< N*8 << " muln"
<< N*6 << " addn"
<< N*7 << " assignementsn";

delete[] x;
delete[] y;
delete[] z;

return 0;
}

Citation :
ticks for f1, pass 1 is around : 4302.5
ticks for f2, pass 1 is around : 26105
For this number of cycles, there is :
8192 mul
6144 add
7168 assignements

Citation :
Parlons de l'x86. Tous les vrais programmeurs lui tapent dessus.

Citation :
In a discussion on the merits of various processors, Torvalds wrote that Intel had made the same mistakes "that everybody else did 15 years ago" when RISC architecture was first appearing. Itanium tries to introduce an architecture that is clean and technically pure, something that just doesn't seem to work in the real world. He claims that Intel "threw out all the good parts of the x86 because people thought those parts were ugly. They aren't ugly, they're the 'charming oddity' that makes it do well."

Citation :
Clever architecture is something that has trapped others in the past. The Alpha processor team spent years learning that many of the architecturally correct ideals they had held needed to be thrown out when it came to the real world. According to Torvalds, "And all the RISC stuff that tried to avoid it was just a BIG WASTE OF TIME. Because the _only_ thing the RISC approach ended up showing was that eventually you have to do the hard stuff anyway, so you might as well design for doing it in the first place."

Citation :
Le RISC, c'est pas un proc, simple, c'est un jeu d'instructions simplifiées...