Discussion :

[rigobert]

Pourrais je avoir un de ces cas à titre d'exemple que je me fasse une idée?

L'assembleur est encore pas mal utilisé pour tout ce qui est traitement de signal en temps réel (video, son) parce que c'est un domaine qui se prête généralement bien à la parallélisation et l'utilisation d'instructions dédiées (genre SSE), ce qui est encore le point faible des compilateurs.

Mais il faut quand même toujours garder à l'esprit que (bien) programmer en assembleur est très coûteux en temps (par rapport à des langages évolués) et donc généralement ... très coûteux tout court !

[homeostasie]

Mais il faut quand même toujours garder à l'esprit que (bien) programmer en assembleur est très coûteux en temps (par rapport à des langages évolués) et donc généralement ... très coûteux tout court !

C'est clair et merci pour ces précisions!

De toute facon, la seule réponse valable sera sûrement :
Citation:
A tester. Lance 10000 fois les deux versions, regarde le temps sur différentes architectures et fait une synthése.

J'ai donc fait les tests avec la fonction suivante où je lance d'abord 50000 fois la proposition 1 puis 50000fois la proposition 2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
void mesureTempsDebug(WIND_TCB *oldTcbPtr, WIND_TCB *newTcbPtr)
{
  	REG_SET regSet;			/*Task registers*/
	TASK_DESC taskDesc;		/*information structure */
	tracePostMortem *TaskInfoTemp = NULL;
	UInt32 tickDeb, tickFin, i;
 
	taskLock();
	tickSet(0);
	tickDeb = tickGet();
	for(i = 0; i < 50000; i++)
	{
   	/*Critical section: temporay storage pointer to optimize the speed.*/
   	TaskInfoTemp = &TaskInfoBuf[indexBuf];
 
   	TaskInfoTemp->taskId = taskNameToId(oldTcbPtr->name);
   	if (taskRegsGet (TaskInfoBuf[indexBuf].taskId, &regSet) != ERROR){
   		TaskInfoTemp->registers = regSet;
   		TaskInfoTemp->TaskSP = (int)GetSP();
		TaskInfoTemp->TaskFP = (int)GetFP(); 
   		TaskInfoTemp->TaskPrevFP = (UInt32)FP_FROM_STACK(regSet.spReg);
   	}
 
	TaskInfoTemp->stackBase = (UInt32) oldTcbPtr->pStackBase;
	TaskInfoTemp->stackLimit = (UInt32) oldTcbPtr->pStackLimit;
	TaskInfoTemp->stackEnd = (UInt32) oldTcbPtr->pStackEnd;
 
   	if (taskInfoGet (TaskInfoTemp->taskId, &taskDesc ) != ERROR){
   		TaskInfoTemp->stackSize = taskDesc.td_stackSize;
   		TaskInfoTemp->stackCurrent = taskDesc.td_stackCurrent;
   		TaskInfoTemp->stackHigh = taskDesc.td_stackHigh;
   	}
	}
	tickFin = tickGet();
	printf("Solution1: tickDeb = %d, tickFin = %d\n\n",tickDeb,tickFin);
 
   	tickSet(0);
	tickDeb = tickGet();
   	for(i = 0; i < 50000; i++)
	{
   	TaskInfoBuf[indexBuf].taskId = taskNameToId(oldTcbPtr->name);
   	if (taskRegsGet (TaskInfoBuf[indexBuf].taskId, &regSet) != ERROR){
   		TaskInfoBuf[indexBuf].registers = regSet;
   		TaskInfoBuf[indexBuf].TaskSP = (int)GetSP();
		TaskInfoBuf[indexBuf].TaskFP = (int)GetFP(); 
   		TaskInfoBuf[indexBuf].TaskPrevFP = (UInt32)FP_FROM_STACK(regSet.spReg);
   	}
 
	TaskInfoBuf[indexBuf].stackBase = (UInt32) oldTcbPtr->pStackBase;
	TaskInfoBuf[indexBuf].stackLimit = (UInt32) oldTcbPtr->pStackLimit;
	TaskInfoBuf[indexBuf].stackEnd = (UInt32) oldTcbPtr->pStackEnd;
 
   	if (taskInfoGet (TaskInfoBuf[indexBuf].taskId, &taskDesc ) != ERROR){
   		TaskInfoBuf[indexBuf].stackSize = taskDesc.td_stackSize;
   		TaskInfoBuf[indexBuf].stackCurrent = taskDesc.td_stackCurrent;
   		TaskInfoBuf[indexBuf].stackHigh = taskDesc.td_stackHigh;
   	}
	}
   	tickFin = tickGet();
	printf("Solution2: tickDeb = %d, tickFin = %d\n\n",tickDeb,tickFin);
   	taskUnlock();
}

Le résultat sur le shell est le suivant:

-> mesureTempsDebug
Solution1: tickDeb = 0, tickFin = 15

Solution2: tickDeb = 0, tickFin = 15

Je suis assez surpris car le temps d'éxécution est le même...Le compilateur ferait il vraiment très bien son travail!
En conclusion, ca semble le cas.

Le système est réglé pour 60ticks/s.
Le temps d'éxécution d'un passage dans une des deux solutions est donc d'environ 5µs.

Si vous avez des remarques vis à vis du résultat, n'hésitez pas!