estoy trabajando en tratar de acelerar algún tipo de procesamiento de datos generales en C. He escrito varias subrutinas de la forma:C: Volviendo un vacío contra el retorno de una doble * de una función parcial
double *do_something(double *arr_in, ...) {
double *arr_out;
arr_out = malloc(...)
for (...) {
do the something on arr_in and put into arr_out
}
return arr_out;
}
I al igual que este estilo porque es fácil de leer y usar, pero a menudo me llaman como:
array = do_something(array,...);
Tendría de código más rápido (y tal vez evitar pérdidas de memoria) si tuviera que usar en su lugar subfunciones vacío como:
void do_something(double *arr_in, ...) {
for (...) {
arr_in = do that something;
}
return;
}
actualización 1: Ejecuté valgrind --leak-check = completo en el ejecutable y parece que no hubo pérdidas de memoria con el primer método. Sin embargo, el ejecutable se vincula a una biblioteca que contiene todas las subrutinas que hice con este formulario, por lo que podría no detectar fugas de la biblioteca.
Tengo curiosidad sobre cómo escribiría las envolturas para liberar la memoria y lo que ** realmente hace, o lo que es un puntero a un puntero, así que evito usar ** la ruta (eso y tal vez lo hice mal porque no se compiló en mi mac).
Aquí hay una subrutina actual:
double *cos_taper(double *arr_in, int npts)
{
int i;
double *arr_out;
double cos_taper[npts];
int M;
M = floor(((npts - 2)/10) + .5);
arr_out = malloc(npts*sizeof(arr_out));
for (i=0; i<npts; i++) {
if (i<M) {
cos_taper[i] = .5 * (1-cos(i * PI/(M + 1)));
}
else if (i<npts - M - 2) {
cos_taper[i] = 1;
}
else if (i<npts) {
cos_taper[i] = .5 * (1-cos((npts - i - 1) * PI/(M + 1)));
}
arr_out[i] = arr_in[i] * cos_taper[i];
}
return arr_out;
}
De los consejos que he recibido aquí, suena como un método mejor sería:
void *cos_taper(double *arr_in, double *arr_out, int npts)
{
int i;
double cos_taper[npts];
int M;
M = floor(((npts - 2)/10) + .5);
for (i=0; i<npts; i++) {
if (i<M) {
cos_taper[i] = .5 * (1-cos(i * PI/(M + 1)));
}
else if (i<npts - M - 2) {
cos_taper[i] = 1;
}
else if (i<npts) {
cos_taper[i] = .5 * (1-cos((npts - i - 1) * PI/(M + 1)));
}
arr_out[i] = arr_in[i] * cos_taper[i];
}
return
}
llamada:
int main() {
int npts;
double *data, *cos_tapered;
data = malloc(sizeof(data) * npts);
cos_tapered = malloc(sizeof(cos_tapered) * npts);
//fill data
cos_taper(data, cos_tapered, npts);
free(data);
...
free(cos_tapered);
...
return 0;
}
Gracias por las respuestas rápidas a todos. Esta es una gran ayuda para un novato sin entrenamiento real de CS y solo sobre la marcha. –
Simplemente ejecuté el código completo y obtuvo hasta el 80% de mi memoria total, por favor. ¡Parece que tengo que hacer una limpieza seria! –
Pequeño nitpick semántico: las funciones con tipo de retorno 'void' no" devuelven un vacío "porque no puede tener una variable' void'. Es una convención que indica que la función no devuelve nada. Pero ya sabes esto. –