Compilazione e differenza di velocita'

[guido84]

Per vedere l'eventuale differenza, ho compilato lo stesso sorgente
come perm.c e perm.cc, in entrambi i casi con e senza l'opzione -O3.
Contro le mie aspettative ho avuto il risultato che il .c vince sul .cc
per circa 1 secondo su circa 34.

Allora ne ho compilato un altro (questa volta di Giacomini, da ail).
Il risultato si e' capovolto: .cc batte .c per circa 1 secondo su 55.

Invece l'O3 ha sempre dato vantaggio in tutti i casi.
(Ho fatto piu' prove successive, per evitare storie con cache o
cose simili, infatti vengono tempi sempre un po' diversi).

Nota.
A entrambi i progrqmmi ho fatto scrivere le 11! permutazini di 11
caratteri, si vede che Giacomini nel sorgente ha dato precedenza
alla didattica...

Penso possa interessare se riporto i sorgenti, tanto non fa danno.
Il comando di esecuzione e' stato:
$: time echo 123456789ab | ./perm > /dev/null
$: time ./giacom $(seq 11) > /dev/null

APRO PARENTESI (come si fara' a redirigere "quel che scrive" time
(builtin), dico "quel che scrive" perche' trattandolo come stout
o stderr non son riuscito in nessun modo a farlo, se qualcuno poi
me lo dice...) CHIUSA PARENTESI

Un'ultima nota. Un binario per Linux, trovato in rete gia' fatto,
da' l'incredibile tempo di circa 13 secondi (sempre per stampare
la stessa cosa eh), quindi c'e' molto da ottimizzare!

Dimenticavo:
Questo seguente come .c l'ho compilato con -std=gnu99, come .cc
invece m'ha detto di toglierla che col plasplas non ci vuole.
Inoltre il maximum l'ho aggiunto e cambiato io, c'era char a[10]
senza la direttiva define.

============= Da Illustre Sconosciuto in rete ==========
#include <stdio.h>
#include <string.h>
#define maximum 16

char a[maximum];

void swap(char *p, char *q)
{
char temp;
temp = *p;
*p = *q;
*q = temp;
}

void permute(char *a, int i, int length)
{
int j;
if (i == length)
{
for(int x=0; x <= length; x++)
printf("%c ", a[x]);
printf("\n");
}
else
{
for (j = i; j <= length; j++)
{
swap((a+i), (a+j));
permute(a, i+1, length);
swap((a+i), (a+j)); //backtrack
}
}
}

int main()
{
scanf("%s", a);
int n = strlen(a);
permute(a, 0, n-1);

return 0;
}
================================


======== Da appunti informatica libera -- by Giacomini ========
/* ================================================================= */
/* permuta <valore>... */
/* Permutazioni. */
/* ================================================================= */

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

/* Variabile globale. */
int iDimArray;

/* ================================================================= */
/* visualizza (<array>, <dimensione>) */
/* ----------------------------------------------------------------- */
void visualizza (int lista[], int dimensione)
{
int i;

for (i = 0; i < dimensione; i++)
{
printf ("%d ", lista[i]);
}
printf ("\n");
}

/* ================================================================= */
/* permuta (<lista>, <inizio>, <fine>) */
/* ----------------------------------------------------------------- */
void permuta (int lista[], int a, int z)
{
int scambio;
int k;

/* Se il segmento di array contiene almeno due elementi, si */
/* procede. */
if ((z - a) >= 1)
{
/* Inizia un ciclo di scambi tra l'ultimo elemento e uno */
/* degli altri contenuti nel segmento di array. */
for (k = z; k >= a; k--)
{
/* Scambia i valori. */
scambio = lista[k];
lista[k] = lista[z];
lista[z] = scambio;

/* Esegue una chiamata ricorsiva per permutare un */
/* segmento piu' piccolo dell'array. */
permuta (lista, a, z-1);

/* Scambia i valori. */
scambio = lista[k];
lista[k] = lista[z];
lista[z] = scambio;
}
}
else
{
/* Visualizza l'array e utilizza una variabile dichiarata */
/* globalmente. */
visualizza (lista, iDimArray);
}
}

/* ================================================================= */
/* Inizio del programma. */
/* ----------------------------------------------------------------- */
int main (int argc, char *argv[])
{
/* int lista[argc-1]; */
int *lista = (int *) malloc ((argc - 1) * sizeof (int));
int i;

/* Considera gli argomenti come gli elementi */
/* dell'array da permutare. */
for (i = 1; i < argc; i++)
{
sscanf (argv[i], "%d", &lista[i-1]);
}

/* Salva la dimensione dell'array nella variabile globale. */
iDimArray = argc-1;

/* Esegue le permutazioni. */
permuta (lista, 0, argc-2);

return 0;
}
==========================================


--
Saluti,
Guido