Well, this is my code:
/****** pru.c ****************************************************/ /**
*
* @file pru.c
*
* @brief Programa para comprobar el rendimiento del procesamiento de una
* matriz con dos modos de ejecucion diferentes.
*
* Este programa lee de fichero una matriz de 1000*1000 elementos y la procesa
* de dos formas, una por filas y otra por columnas, realizando una operación.
* Para compilar en linux se usa: gcc -Wall -o pru pru.c -lpthread -lm
*
* @version 0.9
* @author Jorge Martinez Hernandez
*
* @date 31-05-2016
*
*/ /***************************************************************************/
//using namespace std;
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h> ///< Funciones de potencia y raiz cuadrada
//#include <fstream> ///< Para los ficheros de salida
#include <time.h> ///< Usada para calcular el tiempo
#include <pthread.h> ///< Sirve para crear los hilos
const int NUM = 1000; ///< Longitud del vector
/**
* Datos compartidos por los hilos
*/
pthread_mutex_t m; ///< Cerrojo para los hilos.
float matriz[NUM][NUM]; ///< Matriz de 1000*1000.
float v[NUM]; ///< Vector de test.
int ID_Hilo = 0; ///< Identificador del hilo.
int num_Hilos; ///< Numero de hilos.
int leerMatriz ()
{
int ok = 0;
FILE * f;
if((( f = fopen( "datos.txt", "r" ) ) == NULL )){ ///< Si se produce error de lectura, no se continua
ok = 1;
}
else{
int columnas, filas;
for (columnas = 0; (columnas < NUM) && (!feof(f) ); columnas++)
for (filas = 0; (filas < NUM) && (!feof(f) ); filas++){
fscanf(f, " %f", &matriz[columnas][filas]); ///< Leemos un dato del fichero
}
if ((filas != NUM)||(columnas != NUM)) ///< Esto quiere decir que no ha leido 1000*1000 elementos
ok = 1;
fclose(f);
}
return ok;
}
void procesamientoFilas()
{
int idHilo; ///< ID de ESTE hilo
int trozoActual; ///< Punto donde estamos de la matriz
int columnas, filas; ///< Valores de filas y columnas
pthread_mutex_lock(&m); ///< Bloqueamos el cerrojo para acceso exclusivo
idHilo = ID_Hilo++; ///< Anotamos el ID de ESTE hilo
pthread_mutex_unlock(&m); ///< Desbloqueamos el cerrojo
printf("Hilo procesamientoFilas con ID: %d ha empezado...\n", idHilo);
trozoActual = NUM/num_Hilos; ///< Anotamos cual es el trozo que toca procesar
for (columnas = trozoActual*idHilo; columnas < trozoActual*(idHilo+1) && (columnas < NUM); columnas++) ///< Usamos reparto consecutivo
{
v[columnas] = 0;
for (filas = 0; filas < NUM; filas++)
{
v[columnas] += pow(matriz[columnas][filas], 2); ///< Realizamos la primera operacion requerida sobre la matriz
}
v[columnas] = sqrt(v[columnas]); ///< Realizamos la segunda operacion requerida sobre el vector
}
printf("Hilo procesamientoFilas con ID: %d ha terminado\n", idHilo);
pthread_exit(0);
}
void procesamientoColumnas()
{
int idHilo; ///< ID de ESTE hilo
int trozoActual; ///< Punto donde estamos de la matriz
int columnas, filas; ///< Valores de filas y columnas i j
pthread_mutex_lock(&m); ///< Bloqueamos el cerrojo para acceso exclusivo
idHilo = ID_Hilo++; ///< Anotamos el ID de ESTE hilo
pthread_mutex_unlock(&m); ///< Desbloqueamos el cerrojo
printf("Hilo procesamientoColumnas con ID: %d ha empezado...\n", idHilo);
trozoActual = NUM/num_Hilos;
for (filas = trozoActual*idHilo; (filas < trozoActual*(idHilo+1)) && (filas < NUM); filas++) ///< Usamos reparto consecutivo
{
v[filas] = 0;
for (columnas = 0; columnas < NUM; columnas++)
v[filas] += pow(matriz[columnas][filas], 2); ///< Realizamos la primera operacion requerida sobre la matriz
v[filas] = sqrt(v[filas]); ///< Realizamos la segunda operacion requerida sobre el vector
}
printf("Hilo procesamientoColumnas con ID: %d ha terminado\n", idHilo);
pthread_exit(0);
}
int main(int argc, char *argv[])
{
time_t ini, fin;
void * tipoProcesamiento;
/**
*Inicio del programa
*/
if (argc != 3) ///< Comprobamos que se ha llamado correctamente al programa
{
fprintf(stderr, "Uso columnas: pru num_hilos columnas\n Uso filas: pru num_hilos filas\n");
exit(1); ///< En caso de que no, se dará un mensaje de error
}
/**
* Carga e inicializacion de datos
*/
if (strcmp( argv[2], "filas") == 0) ///< Comprobamos si se pide la operacion por filas...
tipoProcesamiento = procesamientoFilas;
else if (strcmp( argv[2], "columnas") == 0) ///< ...o por columnas
tipoProcesamiento = procesamientoColumnas;
else ///< En caso de que no se cumpla ninguna de las anteriores
{
fprintf(stderr, "Uso columnas: pru num_hilos columnas\n Uso filas: pru num_hilos filas\n");
exit(1);
}
if (leerMatriz() == 0) ///< Lee los datos de la matriz y en caso de que se lea correctamente, procede
{
/**
* Procesamiento de datos
*/
num_Hilos = atoi(argv[1]); ///< Creamos tantos hilos como hayamos pedido en la ejecución
ini = time (NULL); ///< Registro el tiempo de inicio
pthread_t hilos[num_Hilos];
int i;
for (i = 0; i < num_Hilos; i++) ///< Creamos los hilos
pthread_create(&hilos[i], NULL, tipoProcesamiento, &i);
for (i = 0; i < num_Hilos; i++) ///< Espera a que se finalicen los hilos
pthread_join(hilos[i], NULL);
fin = time (NULL); ///< Registro el tiempo de fin
/**
* Muestreo de datos
*/
printf("Tiempo de procesamiento para %d hilo(s): %f", num_Hilos, difftime(fin, ini));
}
else
{
fprintf(stderr, "No se ha podido abrir el archivo. Matriz no leida.");
exit(1);
}
return 0;
}
The problem is in the following lines:
float matriz[NUM][NUM];
float v[NUM];
For some reason these lines generate the following compilation error:
pru.c:36:7: error: variably modified ‘matriz’ at file scope
float matriz[NUM][NUM]; ///< Matriz de 1000*1000.
^
pru.c:36:7: error: variably modified ‘matriz’ at file scope
pru.c:37:7: error: variably modified ‘v’ at file scope
float v[NUM]; ///< Vector de test.
I am compiling on a Linux system with the following line:
gcc -Wall -o pru pru.c -lpthread -lm
I would like to know what the source of the error is and how I could fix it. I leave the complete program so that everything is understood, but I DO NOT need a correction of it. I just want to correct that compilation error.