EDMA3 code crashes my code

/*
 *  ======== main.c ========
 */

#include <xdc/std.h>
#include <stdio.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>

#include <ti/sysbios/BIOS.h>

#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/family/c66/Cache.h>

#include <ti/csl/csl_tsc.h>

#include "Delay_Computation.h"
#include "Delay_Computation_Structures.h"
#include "FilterCoeffs.h"

//EDMA3 LLDs
#include "ti\sdo\edma3\drv\edma3_drv.h"
#include "ti\sdo\edma3\drv\sample\bios6_edma3_drv_sample.h"
//EDMA3 LLDs

#define FHI(a)		_itof(_hi(a))
#define FLO(a)		_itof(_lo(a))

#pragma DATA_ALIGN(FFilterCoefficients, 32);
#pragma DATA_SECTION(FFilterCoefficients,"sect_C0");

    float FFilterCoefficients[UpsamplingFactor][FilterClarity];

#pragma DATA_ALIGN(FFilterCoefficientsAligned, 32);
#pragma DATA_SECTION(FFilterCoefficientsAligned,"sect_C0");

    float FFilterCoefficientsAligned[Vertical_Sensors][2*Horizontal_Sensors][8];

#pragma DATA_ALIGN(IMark, 32);
#pragma DATA_SECTION(IMark,"sect_C0");
#pragma DATA_ALIGN(ISpace, 32);
#pragma DATA_SECTION(ISpace,"sect_C0");

	UInt32 IMark[Vertical_Sensors][Horizontal_Sensors],
	ISpace[Vertical_Sensors][Horizontal_Sensors];

#pragma DATA_ALIGN(IMarkExtended, 32);
#pragma DATA_SECTION(IMarkExtended,"sect_MSMC");

	UInt32 IMarkExtended[Vertical_Sensors][2*Horizontal_Sensors];

#pragma DATA_ALIGN(FShadingCoeffs, 32);
#pragma DATA_SECTION(FShadingCoeffs,"sect_MSMC");

	float FShadingCoeffs[Vertical_Sensors][Vertical_Sensors];

#pragma DATA_ALIGN(FDelayArray,32);
#pragma DATA_SECTION(FDelayArray,"sect_C0");

	float FDelayArray[Vertical_Sensors][Horizontal_Sensors];
/*
#pragma DATA_ALIGN(IIndexArray,32);
#pragma DATA_SECTION(IIndexArray,"sect_C0");

	int IIndexArray[Vertical_Sensors][Horizontal_Sensors];
*/
	unsigned long long ULLStartTime,ULLEndTime;
	extern Semaphore_Handle Delay_Computation_Semaphore;
	extern Semaphore_Handle Beam_Former_Semaphore;
	UInt8 UISteering_Change=1;
	UInt runtimer=0,runtask=0;

	//This is a global structure for Delay Computation Task
	Delay_Computation_Task_Params SDelay_Computation_Params;
	Beam_Former_Task_Params SBeam_Former_Params;

#pragma DATA_ALIGN(FDataArray1, 32);
#pragma DATA_SECTION(FDataArray1,"sect_C0");

	float FDataArray1[nRing][nSensor][2*DataLength] = {
																					#include "data4000.txt"
																					};

#pragma DATA_ALIGN(FDataArray2, 32);
#pragma DATA_SECTION(FDataArray2,"sect_MSMC");

	float FDataArray2[nRing][nSensor][2*DataLength];

#pragma DATA_ALIGN(FOutputArrayUp,4);
#pragma DATA_SECTION(FOutputArrayUp,"sect_C0");

	float FOutputArrayUp[nBeam][IterationCount];

#pragma DATA_ALIGN(FOutputArraySt,4);
#pragma DATA_SECTION(FOutputArraySt,"sect_C0");

	float FOutputArraySt[nBeam][IterationCount];

#pragma DATA_ALIGN(FOutputArrayDn,4);
#pragma DATA_SECTION(FOutputArrayDn,"sect_C0");

	float FOutputArrayDn[nBeam][IterationCount];

//EDMA3  resources
	UInt32 edma3InstanceId = 0;
	// EDMA3 features specific to your device (e.g. found in bios_edma3_drv_sample_C6678_cfg.c)

	//EDMA3_DRV_GblConfigParams sampleParams;
	//EDMA3_DRV_GblConfigParams *globalConfig = &sampleParams;
	// Specifies sharing of EDMA3 between CPU�s
	//EDMA3_DRV_MiscParam miscParam;

	//EDMA3_DRV_ChainOptions Chaining_Options;

	extern Semaphore_Handle Semaphore_For_EDMA_Instance;
	EDMA3_DRV_Result  EDMA_Error_Code;

	extern EDMA3_DRV_InstanceInitConfig sampleInstInitConfig;
	EDMA3_DRV_InstanceInitConfig *InstInitConfig = &sampleInstInitConfig;

	EDMA3_DRV_InitConfig InitCfg;

	EDMA3_DRV_Handle  handleEDMA;

	int32_t SRCBIDX,DSTBIDX,SRCCIDX,DSTCIDX;
	UInt32 BCNTRLD,ACNT,BCNT,CCNT;
	uint16_t Link;

	uint32_t LCH = EDMA3_DRV_DMA_CHANNEL_ANY,Tcc = EDMA3_DRV_TCC_ANY;
//EDMA3  resources

#pragma FUNC_ALWAYS_INLINE(DotpMyFunc);
Void DotpMyFunc(const double Ptr1[restrict], const double Ptr2[restrict], float Ptr3[restrict],float Ptr4[restrict])
{
	int i,j;
	float FSum0,FSum1,FSum2,FSum3,FSum4,FSum5,FSum6,FSum7;
#pragma DATA_MEM_BANK(a,0);
#pragma DATA_MEM_BANK(b,4);
	double  a[4] ,b[4];

for(i=0;i<4;i++)
{
	a[i]=Ptr1[i];
	b[i]=Ptr2[i];
}

	for(i=0,j=0;i<IterationCount/2; i+=4, j+=8)
	{

		FSum0 = FHI(a[0]) * FHI(b[0]);
		FSum1 = FLO(a[0]) * FLO(b[0]);
		FSum2 = FHI(a[1]) * FHI(b[1]);
		FSum3 = FLO(a[1]) * FLO(b[1]);
		FSum4 = FHI(a[2]) * FHI(b[2]);
		FSum5 = FLO(a[2]) * FLO(b[2]);
		FSum6 = FHI(a[3]) * FHI(b[3]);
		FSum7 = FLO(a[3]) * FLO(b[3]);

		FSum0	+= FSum1;
		FSum2	+= FSum3;
		FSum4	+= FSum5;
		FSum6	+= FSum7;
		FSum0	+= FSum2;
		FSum4	+= FSum6;
		Ptr3[j] +=  FSum0 + FSum4;
		Ptr4[j] +=  FSum0 + FSum4;

		a[0]=Ptr1[i+4];

	 	FSum0 = FHI(a[1]) * FHI(b[0]);
		FSum1 = FLO(a[1]) * FLO(b[0]);
		FSum2 = FHI(a[2]) * FHI(b[1]);
		FSum3 = FLO(a[2]) * FLO(b[1]);
		FSum4 = FHI(a[3]) * FHI(b[2]);
		FSum5 = FLO(a[3]) * FLO(b[2]);
		FSum6 = FHI(a[0]) * FHI(b[3]);
		FSum7 = FLO(a[0]) * FLO(b[3]);

		FSum0	+= FSum1;
		FSum2	+= FSum3;
		FSum4	+= FSum5;
		FSum6	+= FSum7;
		FSum0	+= FSum2;
		FSum4	+= FSum6;
		Ptr3[j+2] +=  FSum0 + FSum4;
		Ptr4[j+2] +=  FSum0 + FSum4;

		a[1]=Ptr1[i+5];

	 	FSum0 = FHI(a[2]) * FHI(b[0]);
		FSum1 = FLO(a[2]) * FLO(b[0]);
		FSum2 = FHI(a[3]) * FHI(b[1]);
		FSum3 = FLO(a[3]) * FLO(b[1]);
		FSum4 = FHI(a[0]) * FHI(b[2]);
		FSum5 = FLO(a[0]) * FLO(b[2]);
		FSum6 = FHI(a[1]) * FHI(b[3]);
		FSum7 = FLO(a[1]) * FLO(b[3]);

		FSum0	+= FSum1;
		FSum2	+= FSum3;
		FSum4	+= FSum5;
		FSum6	+= FSum7;
		FSum0	+= FSum2;
		FSum4	+= FSum6;
		Ptr3[j+4] += FSum0 + FSum4;
		Ptr4[j+4] += FSum0 + FSum4;

		a[2]=Ptr1[i+6];

	 	FSum0 = FHI(a[3]) * FHI(b[0]);
		FSum1 = FLO(a[3]) * FLO(b[0]);
		FSum2 = FHI(a[0]) * FHI(b[1]);
		FSum3 = FLO(a[0]) * FLO(b[1]);
		FSum4 = FHI(a[1]) * FHI(b[2]);
		FSum5 = FLO(a[1]) * FLO(b[2]);
		FSum6 = FHI(a[2]) * FHI(b[3]);
		FSum7 = FLO(a[2]) * FLO(b[3]);

		FSum0	+= FSum1;
		FSum2	+= FSum3;
		FSum4	+= FSum5;
		FSum6	+= FSum7;
		FSum0	+= FSum2;
		FSum4	+= FSum6;
		Ptr3[j+6] += FSum0 + FSum4;
		Ptr4[j+6] += FSum0 + FSum4;

		a[3]=Ptr1[i+7];
	}
}
Void EDMA_CallBack(uint32_t tcc,
        EDMA3_RM_TccStatus status,
        void *appData)
{

}
Void Test_Timer_Function(void)
{
	if(UISteering_Change)
	{
		UISteering_Change=0;
		SDelay_Computation_Params.FAngleOffset=LEFT_SECTION;
		SDelay_Computation_Params.FVerticalAngle=0.0;
		SDelay_Computation_Params.FDelayArray=FDelayArray;
		SDelay_Computation_Params.IMark=IMark;
		SDelay_Computation_Params.ISpace=ISpace;

		Semaphore_post(Delay_Computation_Semaphore);
	}
	/*
		SBeam_Former_Params.FFilterCoeffs =FFilterCoefficients;
		SBeam_Former_Params.IMark=IMark;
		SBeam_Former_Params.ISpace=ISpace;
		SBeam_Former_Params.FInputArray= &FInputArray[Ping][0];//[Horizontal_Sensors][IterationCount+Surplous]
		SBeam_Former_Params.FOutputArray=&FOutputArray[Ping][0];//[Num_Vertical_Look_Directions][IterationCount]
		*/
		runtimer++;
		Semaphore_post(Beam_Former_Semaphore);


}

/*
 * Delay_Computation_Task_Wrapper_Function
 */
Void Delay_Compute_Task_Function(void)
{

	while(TRUE)
	{
//Attention: Parameters are to be passed to the task only via messages or mailboxes! Change later

	Semaphore_pend(Delay_Computation_Semaphore, BIOS_WAIT_FOREVER);

	Delay_Computation_Function(SDelay_Computation_Params.FAngleOffset,
												SDelay_Computation_Params.FVerticalAngle,
												SDelay_Computation_Params.FDelayArray);

	ReshapeFilterCoeffs(FilterCoeffs, FFilterCoefficients);

	MarkSpace_Compute(FDelayArray, IMark, ISpace);

	Delay_Rearrange(FFilterCoefficients,ISpace,FFilterCoefficientsAligned);

	Mark2MarkExtended(IMark,IMarkExtended);

	}
}

/*
 * Beam Former Task Function
 */
Void BeamFormerTTD3D_Task_Function(void)
{
	int IChannelCount,IBeamCount;
	int IRow, IColumn;
	UInt32 ITemp;

	const double * restrict Ptr1A;
	const double * restrict Ptr1B;
	const double * restrict PtrA;
	float* PtrOut1;
	float* PtrOut2;
	const double* Ptr3;
	const double* Ptr4;

	while(TRUE)
	{
		Semaphore_pend(Beam_Former_Semaphore, BIOS_WAIT_FOREVER);
		runtask++;
		//Attention: Parameters are to be passed to the task only via messages or mailboxes! Change later


		for(IRow=0 ; IRow < Vertical_Sensors ; IRow++ )
				{
					IBeamCount=0;

					for(IChannelCount=0; IChannelCount < nSensor; IChannelCount++)
						{
							Ptr1A=(const double*)&FDataArray1[IRow][IChannelCount][0];
							Ptr1B=(const double*)&FDataArray2[IRow][IChannelCount][0];
							PtrA=(const double*)&FFilterCoefficientsAligned[IRow][0][0];

							for(IColumn=0; IColumn< Horizontal_Sensors ; IColumn++)
								{

									ITemp = IMarkExtended[IRow][IColumn];

										if( ITemp & 0x4 )
										{
										Ptr3 =(const double*) ((UInt32)Ptr1B +  ITemp - 4); //if 17 is the shift, say then locate to 16 since already one delayed while storage
										Ptr4 =(const double*) ((UInt32)Ptr1A + ITemp + 4); //point to 18 to get the 18th shift
										}
										else
										{
										Ptr3 = (const double*) ((UInt32)Ptr1A + ITemp);
										Ptr4 = (const double*) ((UInt32)Ptr1B + ITemp);//1 shift, delayed already
										}

									PtrOut1 = &FOutputArrayUp[(IBeamCount + IColumn - Horizontal_Sensors) % nBeam][0];
									PtrOut2 = &FOutputArrayUp[(IBeamCount + 2*Horizontal_Sensors - IColumn -1 - Horizontal_Sensors) % nBeam][0];

									DotpMyFunc(Ptr3,PtrA,PtrOut1,PtrOut2);

									PtrOut1 = &FOutputArrayUp[(IBeamCount + IColumn - Horizontal_Sensors) % nBeam][1];
									PtrOut2 = &FOutputArrayUp[(IBeamCount + 2*Horizontal_Sensors - IColumn -1 - Horizontal_Sensors) % nBeam][1];

									DotpMyFunc(Ptr4,PtrA,PtrOut1,PtrOut2);

									PtrA+=4;//Note:This is a double variable
								}
							IBeamCount+=2;
							//printf("                             %d\n",IBeamCount);
						}
			}

	}

}
/*
 * MyStartupFunction
 */
Void MyStartupFunction(void)
{

	Cache_Size all_cache_sizes;

	all_cache_sizes.l1pSize=Cache_L1Size_32K;
	all_cache_sizes.l1dSize=Cache_L1Size_32K;
	all_cache_sizes.l2Size=Cache_L2Size_512K;

	Cache_setSize(&all_cache_sizes);
	Cache_wbInvAll();
	Cache_setMode(Cache_Type_ALL, Cache_Mode_NORMAL );

	SDelay_Computation_Params.FAngleOffset=LEFT_SECTION;
	SDelay_Computation_Params.FVerticalAngle=0.0;
	SDelay_Computation_Params.FDelayArray=FDelayArray;
	SDelay_Computation_Params.IMark=IMark;
	SDelay_Computation_Params.ISpace=ISpace;

	ReshapeFilterCoeffs(FilterCoeffs, FFilterCoefficients);//Here the stored filter coefficients are reshaped to aid the poly-phase implementation


	Delay_Computation_Function(SDelay_Computation_Params.FAngleOffset,
												SDelay_Computation_Params.FVerticalAngle,
												SDelay_Computation_Params.FDelayArray);

	MarkSpace_Compute(SDelay_Computation_Params.FDelayArray	,
									SDelay_Computation_Params.IMark,
									SDelay_Computation_Params.ISpace);


	//EDMA3_DRV_create (edma3InstanceId, globalConfig, (void *) &miscParam);

	EDMA_Error_Code = EDMA3_DRV_create (edma3InstanceId, NULL, NULL);

	//printf("\nEDMA_Error_Code = %d.", EDMA_Error_Code);

	InitCfg.isMaster = TRUE;
	InitCfg.regionId = 1;
	InitCfg.drvSemHandle = &Semaphore_For_EDMA_Instance;
	InitCfg.drvInstInitConfig = InstInitConfig;//This is a structure which is loaded from the edma_drv.h
	//InitCfg.drvInstInitConfig = NULL;//This is a structure which is loaded from the edma_drv.h

	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
	handleEDMA = EDMA3_DRV_open(edma3InstanceId, (Void*) &InitCfg, &EDMA_Error_Code);
	}

	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
	EDMA_Error_Code = EDMA3_DRV_requestChannel (handleEDMA, &LCH, &Tcc,  (EDMA3_RM_EventQueue)0 , &EDMA_CallBack,NULL);
	}
//#if 0
	//EDMA3_DRV_unlinkChannel (handleEDMA,LCH);//Linking is cleared if already linked

	//EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_SAM, EDMA3_DRV_ADDR_MODE_INCR);
	//EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_DAM, EDMA3_DRV_ADDR_MODE_INCR);
	//EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_SYNCDIM, EDMA3_DRV_SYNC_AB);

	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
	EDMA_Error_Code = EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_STATIC, EDMA3_DRV_STATIC_DIS);
	}
	//EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_FWID, EDMA3_DRV_W8BIT);
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
	EDMA_Error_Code = EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_TCCMODE, EDMA3_DRV_TCCMODE_NORMAL);
	}

	//EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_TCC, 0);
	//Requires only if chaining is enabled, to set transfer completion code

	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_TCINTEN, EDMA3_DRV_TCINTEN_EN);
	}
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_ITCINTEN, EDMA3_DRV_ITCINTEN_DIS);
	}
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_TCCHEN, EDMA3_DRV_TCCHEN_DIS);
	}
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setOptField (handleEDMA, LCH, EDMA3_DRV_OPT_FIELD_ITCCHEN, EDMA3_DRV_ITCCHEN_DIS);
	}

	/*
	Chaining_Options.itcchEn =	EDMA3_DRV_ITCCHEN_DIS ;
	Chaining_Options.itcintEn =EDMA3_DRV_ITCINTEN_DIS;
	Chaining_Options.tcchEn =EDMA3_DRV_TCCHEN_DIS;
	Chaining_Options.tcintEn =EDMA3_DRV_TCINTEN_EN;
	Requires if chaining is to be used.
	*/
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setSrcParams (handleEDMA, LCH, (signed char*) GLOBAL_ADDR(_FDataArray1), EDMA3_DRV_ADDR_MODE_INCR, EDMA3_DRV_W8BIT);
	}
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setDestParams(handleEDMA, LCH,(signed char*) GLOBAL_ADDR(_FDataArray2), EDMA3_DRV_ADDR_MODE_INCR, EDMA3_DRV_W8BIT);
	}
	SRCBIDX = 2048*4;//2048 float values
	SRCCIDX = 2048*4;
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setSrcIndex (handleEDMA, LCH, SRCBIDX, SRCCIDX);
	}
	DSTBIDX = 2048*4;//2048 float values
	DSTCIDX = 2048*4;
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
		EDMA_Error_Code = EDMA3_DRV_setDestIndex (handleEDMA, LCH, DSTBIDX, DSTCIDX);
	}
	BCNTRLD= 2048;
	ACNT = 4;
	BCNT = 2048;
	CCNT = 7*72;
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
	EDMA_Error_Code = EDMA3_DRV_setTransferParams (handleEDMA, LCH, ACNT, BCNT, CCNT, BCNTRLD,EDMA3_DRV_SYNC_A);
	}
	if(EDMA_Error_Code == EDMA3_DRV_SOK)
	{
	//	EDMA_Error_Code = EDMA3_DRV_enableTransfer (handleEDMA, LCH, EDMA3_DRV_TRIG_MODE_MANUAL);
	}
printf("\n EDMA INIT COMPLETE.");

//#endif

	int i,j;
	for(i=0;i<144;i++)
		for(j=0;j<1024;j++)
          FOutputArrayUp[i][j]=0.0;

	/*
	for(i=0;i<7;i++)
		for(j=0;j<72;j++)
			for(k=0;k<2047;k++)
				FDataArray2[i][j][k]=FDataArray1[i][j][k+1];
*/
	//Delay_Rearrange(FFilterCoefficients,ISpace,FFilterCoefficientsAligned);

}

/*
 *  ======== main ========
 */

//#define Disable_Checks


Void main(){
    System_printf("enter main()\n");
/*
 * This is a Global Structure for managing the Delay Computation Task
 * Default Values
 */
    CSL_tscEnable();

    //ULLStartTime = CSL_tscRead() ;
    //Delay_Computation_Function(ON_ELEMENT, 0.0, IMark,ISpace, FDelayArray);
    //ULLEndTime = CSL_tscRead() - ULLStartTime;
    //MarkSpace_Compute(FDelayArray, IMark,ISpace);
    //BeamFormTTD3D(FFilterCoeffs,IMark,ISpace, FArrayIndex, FOutput);
	//miscParam.isSlave = FALSE;


    BIOS_start();     /* enable interrupts and start SYS/BIOS */
}

Exception generated while program abort, What could be the reason?

[C66xx_0] 5a8 B25=0xc3f25b0
B26=0x805c9174 B27=0x1
B28=0x805c9174 B29=0x1
B30=0xc3f25a0 B31=0x805dd79d
NTSR=0x1d
ITSR=0xc3f2590
IRP=0x0
SSR=0xc3f24f4
AMR=0x2
RILC=0x0
ILC=0xc3f2598
Exception at 0x3c22f4
EFR=0x2 NRP=0x3c22f4
Internal exception: IERR=0x1
Instruction fetch exception
ti.sysbios.family.c64p.Exception: line 255: E_exceptionMin: pc = 0x805ba020, sp = 0x0c3f25b4.
To see more exception detail, use ROV or set 'ti.sysbios.family.c64p.Exception.enablePrint = true;'
xdc.runtime.Error.raise: terminating execution
5a8 B25=0xc3f25b0
B26=0x805c9174 B27=0x1
B28=0x805c9174 B29=0x1
B30=0xc3f25a0 B31=0x805dd79d
NTSR=0x1d
ITSR=0xc3f2590
IRP=0x0
SSR=0xc3f24f4
AMR=0x2
RILC=0x0
ILC=0xc3f2598
Exception at 0x3c22f4
EFR=0x2 NRP=0x3c22f4
Internal exception: IERR=0x1
Instruction fetch exception