• 状态
  • 已锁定 已锁定
  • 回复 6 回复
  • 订户 14 订户
  • 视图 2676 视图
  • 用户 0 会员在此处
选项
选项
相关

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

TMDSEVM6678: 多核程序设计

puyang sun
Part Number: TMDSEVM6678


通过共享内存和运行的核号来设计一个对矩阵做FFT的并行程序：

我把待处理的矩阵放到ddr中，矩阵逐行存放，实部和虚部交替存放。然后用CSL_chipReadReg函数得到当前运行的核号，根据核号决定每个核心对矩阵的那几行做FFT，每行做完之后用CACHE_wbL1d函数写回。整个函数的基本流程就是这样，

在测试的时候，发现八个核心没办法同时运行，有几个核心最后得到的结果是0。但是如果每个核心单独运行，就能得到结果。

想请教一下在程序较为简单的的情况下，能否直接通过共享内存和核心号进行并行程序的设计？

  • 0 回复 Nancy Wang

    现在我想对同一个矩阵的不同行进行处理，实际上每个核心处理的数据地址并不互相冲突，请问这种情况还需要使用硬件信号量保证互斥访问吗

  • 0 回复 puyang sun
    TI__Guru** 110395 points

    地址不冲突不需要。打印信息显示的处理流程是怎么样的？是访问数据有问题还是处理部分有问题。

  • 0 回复 Nancy Wang

    是处理的部分有问题

  • 0

    我的处理过程和下面的这个程序类似：

    1、在msm里设置了一个flag数组，每个核做完操作之后将flag[coreNum*16]置1，当8个标志位都为1时，同时进行后面的操作。

    2、对矩阵的每一行补零，然后做FFT。

    遇到的问题：

    1、在进行同步的时候，0核会在do whie的循环中跳不出来，1核到7核都会从循环中跳出，进行后面的操作，这是为什么，可以通过这种在msm中设标志位的方式做同步吗？手册上面说L1d的Cache Line是64个字节，是不是一次最少写回64个字节的意思？

    2、不同的核心分别对矩阵的不同行补零，并做FFT，为什么有的核心输出的结果全为零，有的核心就能输出正确的结果？

    #include<c6x.h>
    #include<stdio.h>
    #include<stdlib.h>
    #include <math.h>
    #include"csl.h"
    #include"csl_chip.c"
    #include"csl_types.h"
    #include"csl_cache.h"
    #include"csl_cacheAux.h"
    #include"csl_xmcAux.h"
    #include<ti/dsplib/dsplib.h>
    #include<string.h>
    #pragma DATA_SECTION(flag,".msm")
    int flag[128]={0};
    #pragma DATA_SECTION(Matrix_input,".ddr")
    float Matrix_input[32*28*2];
    #pragma DATA_SECTION(Matrix_output,".ddr")
    float Matrix_output[32*32*2];
    unsigned char brev[64] =
    {
    0x00, 0x20, 0x10, 0x30, 0x08, 0x28, 0x18, 0x38,
    0x04, 0x24, 0x14, 0x34, 0x0c, 0x2c, 0x1c, 0x3c,
    0x02, 0x22, 0x12, 0x32, 0x0a, 0x2a, 0x1a, 0x3a,
    0x06, 0x26, 0x16, 0x36, 0x0e, 0x2e, 0x1e, 0x3e,
    0x01, 0x21, 0x11, 0x31, 0x09, 0x29, 0x19, 0x39,
    0x05, 0x25, 0x15, 0x35, 0x0d, 0x2d, 0x1d, 0x3d,
    0x03, 0x23, 0x13, 0x33, 0x0b, 0x2b, 0x1b, 0x3b,
    0x07, 0x27, 0x17, 0x37, 0x0f, 0x2f, 0x1f, 0x3f
    };
    void tw_gen_i (float *w, int n)
    {
    int i, j, k;
    float PI;
    PI=3.1415926;
    for (j = 1, k = 0; j <= n >> 2; j = j << 2)
    {
    for (i = 0; i < n >> 2; i += j)
    {
    w[k] = sinf (2 * PI * i / n);
    w[k + 1] = cosf (2 * PI * i / n);
    w[k + 2] = sinf (4 * PI * i / n);
    w[k + 3] = cosf (4 * PI * i / n);
    w[k + 4] = sinf (6 * PI * i / n);
    w[k + 5] = cosf (6 * PI * i / n);
    k += 6;
    }
    }
    }
    int main(void)
    {
    int coreNum;
    coreNum=CSL_chipReadReg(CSL_CHIP_DNUM);
    int i,j,length;
    length=32/8;
    for(i=coreNum*length;i<(coreNum+1)*length;i++)
    {
    for(j=0;j<56;j++)
    {
    Matrix_input[i*56+j]=i+1;
    }
    }
    flag[coreNum*16]=1;
    CACHE_wbL1d(&flag[coreNum*16],16*4,CACHE_WAIT);
    _mfence();
    _mfence();
    do
    {
    CACHE_invL1d(&flag[0],128*4,CACHE_WAIT);
    _mfence();
    _mfence();
    }
    while(flag[0]==0|flag[16]==0|flag[32]==0|flag[48]==0|flag[64]==0|flag[80]==0|flag[96]==0|flag[112]==0);
    float w[64];
    tw_gen_i(&w[0],32);
    float array_input[64];
    for(i=coreNum*length;i<(coreNum+1)*length;i++)
    {
    memset(&array_input[0],0,64*sizeof(float));
    memcpy(&array_input[0],&Matrix_input[i*28*2],56*sizeof(float));
    DSPF_sp_fftSPxSP(32,&array_input[0],&w[0],&Matrix_output[i*64],brev,2,0,32);
    }
    return 0;
    }