c - 如何优化我的 C 代码？

Question

我尝试在 FPGA (Zynq ZC 702) 中实现小波变换的 C 代码，但代码卡住了，这是因为内存问题，所以我应该优化我的代码，但我不知道如何优化。

任何人都可以给我一些如何做到这一点的想法吗？

这是主要代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "wavemin.h"
#include "waveaux.h"
#include "waveaux.c"
#include "wavemin.c"

int main() {
    printf("Hello World1 \n\r");
    wave_object obj;
    wt_object wt;
    float *inp, *out;
    int N, i, J,k;
    float temp[1280] = {};
    char *name = "db4";
    obj = wave_init(name);

    printf("Hello World2 \n\r");
    N = 1280;
    inp = (float*)malloc(sizeof(float) * N);
    out = (float*)malloc(sizeof(float) * N);

    //wmean = mean(temp, N);
    for (i = 0; i < N; ++i) {
        inp[i] = temp[i];

        printf("Hello World3 \n\r");
        //printf("%g \n", inp[i]);
    }

    J = 4; //Decomposition Levels
    wt = wt_init(obj, "dwt", N, J);    // Initialize the wavelet transform object
    printf("Hello World4 \n\r");
    setDWTExtension(wt, "sym");       // Options are "per" and "sym". Symmetric  is the default option
    printf("Hello World5 \n\r");

    setWTConv(wt, "direct");
    printf("Hello World6 \n\r");
    dwt(wt, inp);     // Perform DWT
    printf("Hello World7 \n\r");

    //getDWTAppx(wt, out, wt->length[0]);
    //  printf("Approximation Coefficients Level 1 \n");
    //   for (i = 0; i < wt->length[0]; ++i) {
    // printf("%g ", out[i]);
    //  }
    // printf("\n\n");
    for (k = 1; k <= J; ++k) {
        getDWTDetail(wt, out, wt->length[k], k);
        printf("Detail Coefficients Level %d Length %d \n",
               k, wt - length[k]);
        for (i = 0; i < wt->length[k]; ++i) {
            printf("%g ", out[i]);
        }
        printf("\n\n");
    }
    wt_summary(wt);// Prints the full summary.
    printf("Hello World8 \n\r");
    wave_free(obj);
    wt_free(wt);
    free(inp);
    free(out);

    return 0;
}

代码的另一部分，其中有 main 函数中使用的函数:

#include "wavemin.h"

wave_object wave_init(char *wname) {
    wave_object obj = NULL;
    int retval;
    retval = 0;

    if (wname != NULL) {
        retval = filtlength(wname);
    }

    obj = (wave_object)malloc(sizeof(struct wave_set) + sizeof(float) * 4 * 
                              retval);

    obj->filtlength = retval;
    obj->lpd_len = obj->hpd_len = obj->lpr_len = obj->hpr_len = obj->filtlength;
    strcpy(obj->wname, wname);
    if (wname != NULL) {
        filtcoef(wname, obj->params, obj->params + retval, obj->params + 2 * 
                 retval, obj->params + 3 * retval);
    }
    obj->lpd = &obj->params[0];
    obj->hpd = &obj->params[retval];
    obj->lpr = &obj->params[2 * retval];
    obj->hpr = &obj->params[3 * retval];

    return obj;
}

wt_object wt_init(wave_object wave, char *method, int siglength, int J) {
    int size, i, MaxIter;
    wt_object obj = NULL;

    size = wave->filtlength;

    MaxIter = wmaxiter(siglength, size);

    if (!strcmp(method, "dwt") || !strcmp(method, "DWT")) {
        obj = (wt_object)malloc(sizeof(struct wt_set) + sizeof(float) * 
                                (siglength + 2 * J * (size + 1)));
        obj->outlength = siglength + 2 * J * (size + 1); // Default
        strcpy(obj->ext, "sym"); // Default
    }

    obj->wave = wave;
    obj->siglength = siglength;
    obj->J = J;
    obj->MaxIter = MaxIter;
    strcpy(obj->method, method);

    if (siglength % 2 == 0) {
        obj->even = 1;
    }
    else {
        obj->even = 0;
    }

    strcpy(obj->cmethod, "direct"); // Default
    obj->cfftset = 0;
    obj->lenlength = J + 2;
    obj->output = &obj->params[0];
    if (!strcmp(method, "dwt") || !strcmp(method, "DWT")) {
        for (i = 0; i < siglength + 2 * J * (size + 1); ++i) {
            obj->params[i] = 0.0;
        }
    }
    //wave_summary(obj->wave);

    return obj;
}


static void dwt_sym(wt_object wt, float *inp, int N, float *cA, int len_cA, 
                    float *cD, int len_cD) {
    int i, l, t, len_avg;

    len_avg = wt->wave->lpd_len;

    for (i = 0; i < len_cA; ++i) {
        t = 2 * i + 1;
        cA[i] = 0.0;
        cD[i] = 0.0;
        for (l = 0; l < len_avg; ++l) {
            if ((t - l) >= 0 && (t - l) < N) {
                cA[i] += wt->wave->lpd[l] * inp[t - l];
                cD[i] += wt->wave->hpd[l] * inp[t - l];
                printf("world1 \n\r");
            }
            else if ((t - l) < 0) {
                cA[i] += wt->wave->lpd[l] * inp[-t + l - 1];
                cD[i] += wt->wave->hpd[l] * inp[-t + l - 1];
                printf("world2 \n\r");
            }
            else if ((t - l) >= N) {
                cA[i] += wt->wave->lpd[l] * inp[2 * N - t + l - 1];
                cD[i] += wt->wave->hpd[l] * inp[2 * N - t + l - 1];

                printf("world3 \n\r");
            }
        }
    }
}

void dwt(wt_object wt, float *inp) {
    int i, J, temp_len, iter, N, lp;
    int len_cA;
    float *orig, *orig2;

    temp_len = wt->siglength;
    J = wt->J;
    wt->length[J + 1] = temp_len;
    wt->outlength = 0;
    wt->zpad = 0;
    orig = (float*)malloc(sizeof(float) * temp_len);
    orig2 = (float*)malloc(sizeof(float) * temp_len);

    for (i = 0; i < wt->siglength; ++i) {
        orig[i] = inp[i];
        printf("Hello1 \n\r");
    }

    if (wt->zpad == 1) {
        orig[temp_len - 1] = orig[temp_len - 2];
        printf("Hello2 \n\r");
    }

    N = temp_len;
    lp = wt->wave->lpd_len;

    if (!strcmp(wt->ext, "sym")) {
        //printf("\n YES %s \n", wt->ext);
        i = J;
        while (i > 0) {
            N = N + lp - 2;
            N = (int)ceil((float)N / 2.0);
            wt->length[i] = N;
            wt->outlength += wt->length[i];
            i--;
        }
        wt->length[0] = wt->length[1];
        wt->outlength += wt->length[0];
        N = wt->outlength;
        printf("Hello3 \n\r");

        for (iter = 0; iter < J; ++iter) {
            len_cA = wt->length[J - iter];
            N -= len_cA;
            dwt_sym(wt, orig, temp_len, orig2, len_cA, wt->params + N, len_cA);
            temp_len = wt->length[J - iter];
            printf("Hello4 \n\r");

            if (iter == J - 1) {
                for (i = 0; i < len_cA; ++i) {
                    wt->params[i] = orig2[i];
                    printf("Hello5 \n\r");
                }
            } else {
                for (i = 0; i < len_cA; ++i) {
                    orig[i] = orig2[i];
                    printf("Hello6 \n\r");
                }
            }
        }
    } else {
        printf("Signal extension can be either per or sym");
        exit(-1);
    }

    free(orig);
    free(orig2);
}

void setDWTExtension(wt_object wt, char *extension) {
    if (!strcmp(extension, "sym")) {
        strcpy(wt->ext, "sym");
    } else {
        printf("Signal extension can be either per or sym");
        exit(-1);
    }
}

void setWTConv(wt_object wt, char *cmethod) {
    if (!strcmp(cmethod, "direct")) {
        strcpy(wt->cmethod, "direct");
    }
}

void getDWTDetail(wt_object wt, float *detail, int N, int level) {
    /*
       returns Detail coefficents at the jth level where j = 1,2,.., J
       and Wavelet decomposition is stored as
       [A(J) D(J) D(J-1) ..... D(1)] in wt->output vector
       Use getDWTAppx() to get A(J)
       Level 1 : Length of D(J), ie N, is stored in wt->length[1]
       Level 2 :Length of D(J-1), ie N, is stored in wt->length[2]
       ....
       Level J : Length of D(1), ie N, is stored in wt->length[J]
     */
    int i, iter, J;
    J = wt->J;

    if (level > J) {
        printf("The decomposition only has %d levels", J);
    }

    iter = wt->length[0];

    for (i = 1; i < level; ++i) {
        iter += wt->length[i];
    }

    for (i = 0; i < N; ++i) {
        detail[i] = wt->output[i + iter];
    }
}

void getDWTAppx(wt_object wt, float *appx, int N) {
    /*
       Wavelet decomposition is stored as
       [A(J) D(J) D(J-1) ..... D(1)] in wt->output vector

       Length of A(J) , N = wt->length[0]
     */
    int i;

    for (i = 0; i < N; ++i) {
        appx[i] = wt->output[i];
    }
}

void wt_summary(wt_object wt) {
    int i;
    int J, t;
    J = wt->J;

    printf("Wavelet Coefficients are contained in vector : %s \n", "output");
    printf("\n");
    printf("Approximation Coefficients \n");
    printf("Level %d Access : output[%d] Length : %d \n",
           1, 0, wt->length[0]);
    printf("\n");
    printf("Detail Coefficients \n");
    t = wt->length[0];
    for (i = 0; i < J; ++i) {
        printf("Level %d Access : output[%d] Length : %d \n",
               i + 1, t, wt->length[i + 1]);
        t += wt->length[i + 1];
    }
    printf("\n");

}
void wave_free(wave_object object) {
    free(object);
}

void wt_free(wt_object object) {
    free(object);
}

enter image description here

Answer 1

在你的代码中

1. 始终检查 malloc 是否返回非 NULL 值

2. 当您声明大量局部变量并执行大量 malloc 时，请检查链接器文件中的堆栈和堆设置 - 我怀疑(nomen omen)堆栈溢出或失败的 malloc。

它是一个裸机程序还是在某种操作系统下运行它？