/*  V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
*   Copyright (C) 2026  ChaCha
*
*   This program is free software: you can redistribute it and/or modify
*   it under the terms of the GNU General Public License as published by
*   the Free Software Foundation, either version 3 of the License, or
*   (at your option) any later version.
*
*   This program is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*   GNU General Public License for more details.
*
*   You should have received a copy of the GNU General Public License
*   along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#define _BSD_SOURCE 1
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <getopt.h>

#include "cvg.h" 
#include <glide.h>
#include "sst1init.h"
#include "fxpci.h"

#include "V2MemTest.h"
#include "FaultSources.h"
#include "Utils.h"
#include "Draw.h"

#include "Test_Common.h"
#include "Test_Control.h"
#include "Test_Address.h"
#include "Test_Data.h"
#include "Test_Data_Huge.h"
#include "Test_Data_NoMem.h"

const char* szErrorMsg[] =
{
	"no error.", 									// E_ERROR__NO_ERROR
	"unknown error.", 								// E_ERROR__UNKNOWN_ERROR
	"unknown argument found in command line.",		// E_ERROR__UNKNOWN_ARGUMENT
	"wrong argument value.", 						// E_ERROR__BAD_ARGUMENT_VALUE
	"error initializing Voodoo² board.",			// E_ERROR__SST1_INIT,
	"error getting Voodoo² board informations.",	// E_ERROR__SST1_GET_INFO,
	"not enough FBI RAM to process TMU tests.",		// E_ERROR__NOT_ENOUGH_FBI_RAM,
	"TMU not found.",								// E_ERROR__TMU_NOT_FOUND,
	"no TMU selected.",								// E_ERROR__NO_TMU_SELECTED,
	"wrong number of TMU selected.",				// E_ERROR__WRONG_TMU_SELECTED
};

const char szTitle[] =
	"v2-tmu-memtester-%d.%d.%d - A CLI Tool to test & fix Voodoo² TMU System\n"
	"Copyright (C) 2026  ChaCha\n";

const char szLicence[] =
	"This program  is free software : you  can redistribute  it  and/or modify it under\n"
	"the  terms of the  GNU  General Public License  as published by the  Free Software\n"
	"Foundation either version 3 of the License, or (at your option) any later version.\n"
	"This program  is distributed in the hope  that it will be  useful, but WITHOUT ANY\n"
	"WARRANTY !\n";

const char szKool[] =
	"Oh nooo.... Have fun fixing your Holy Voodoo² !\n"
	"Note: Do not forget to sleep though :) !\n";
	
const char szKool2[] =
	"Did it just worked ?!\n";

const char szHelp[] =
"Usage: ./v2-tmu-memtester [options]\n"
	"\n"
	"General options:\n"
	"  -h, --help                 Show this help and exit.\n"
	"      --version              Print version (MAJOR.MINOR.PATCH) and exit.\n"
	"  -n, --num <N>              Number of loops (default: 1).\n"
	"  -q, --quick                Quicker test (no pre-heat).\n"
	"  -c, --continue             Continue testing even when error found.\n"
	"  -f, --force                Force test (not detected TMU / RAM).\n"
	"      --silent               Silent mode (suppress normal output).\n"
	"\n"
	"Verbosity:\n"
	"  -v                         Increase log level by one step (repeatable).\n"
	"                             Levels: 0=ERR, 1=WARN, 2=INFO, 3=DEBUG, 4=TRACE\n"
	"                             Default: 2 (INFO). Example: -v -> DEBUG.\n"
	"\n"
	"Target selection:\n"
	"      --tmu0                 Enable only tests for TMU0.\n"
	"      --tmu1                 Enable only tests for TMU1.\n"
	"\n"
	"Test selection [ all if none set ] :\n"
	"      --no-mem               Run no-mem test.\n"
	"      --control              Run control lines tests.\n"
	"      --address              Run address tests.\n"
	"      --data                 Run data tests.\n"
	"      --data-huge            Run large/extended data tests.\n"
	"\n"
	"TMU RAM limit override:\n"
	"      --tmu0-ram <MB>        Force TMU0 RAM size: -1=auto, 1..4=MB.\n"
	"      --tmu1-ram <MB>        Force TMU1 RAM size: -1=auto, 1..4=MB.\n"
	"\n"
	"Examples:\n"
	"  ./v2-tmu-memtester --tmu0 --address -v\n"
	"  ./v2-tmu-memtester --tmu0-ram 2 --tmu1-ram -1 -n 10\n"
	"  ./v2-tmu-memtester --tmu1 --data-huge\n";

def_sOptions sOptions = {
	.eLogLevel = E_LOGLEVEL__INFO,
	.bSilent = false,
	.lNumLoops = 1,
	.bTestTMU0 = false,
	.eTMU0RamLimit = E_TMU_RAMSIZE__AUTO,
	.bTestTMU1 = false,
	.eTMU1RamLimit = E_TMU_RAMSIZE__AUTO,
	.bTestTMUAddress = false,
	.bTestTMUControl = false,
	.bTestTMUData = false,
	.bTestTMUDataHuge = false,
	.bTestNoMem = false,
	.bQuick = false,
	.bForce = false,
	.bContinue = false,
};

static struct option long_args[] = {
/*	{<NAME>,		<HAS_ARG>,			<FLAG>,						<VAL> */
	{"help",		no_argument,		NULL,						'h'},
	{"num",			required_argument,	NULL,						'n'},
	{"force",		no_argument,		NULL,						'f'},
	{"continue",	no_argument,		NULL,						'c'},
	{"silent",		no_argument,		&sOptions.bSilent,			true},
	{"quick",		no_argument,		NULL,						'q'},
	{"tmu0",		no_argument,		&sOptions.bTestTMU0,		true},
	{"tmu1",		no_argument,		&sOptions.bTestTMU1,		true},
	{"control",		no_argument,		&sOptions.bTestTMUControl,	true},
	{"address",		no_argument,		&sOptions.bTestTMUAddress,	true},
	{"data",		no_argument,		&sOptions.bTestTMUData,		true},
	{"data-huge",	no_argument,		&sOptions.bTestTMUDataHuge,	true},
	{"no-mem",		no_argument,		&sOptions.bTestNoMem,		true},
	{"tmu0-ram", 	required_argument,	NULL,						3},
	{"tmu1-ram", 	required_argument,	NULL,						1},
	{"version",		no_argument,		NULL,						2},
};


static def_sFaultSourceScoreRec 
ar_dFaultScores_no_mem[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec 
ar_dFaultScores_control[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec 
ar_dFaultScores_address[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec 
ar_dFaultScores_data[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec 
ar_dFaultScores_data_random[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec 
ar_dFaultScores_data_huge[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec*
ar_dFaultScores_Set[6];

const unsigned int uNb_dFaultScores_Set =
sizeof(ar_dFaultScores_Set)/sizeof(def_sFaultSourceScoreRec*);

static def_sFaultSourceScoreRec 
ar_dFaultScores_ALL[NB_FAULT_SOURCE];

static def_sFaultSourceScoreRec 
ar_dFaultScores_sorted[NB_FAULT_SOURCE];

#define _DEF_TEST_TIME_PER_MB_S	5

int main(const int argc, char ** const argv)
{
	int Status = 0;
	unsigned long long ullNbErrorAll = 0;
	const unsigned char boardNum = 0;
	int option_index = 0;
	int opt;
	bool bQuit = false;
	FxU32* sst = NULL;
	
	ar_dFaultScores_Set[0] = ar_dFaultScores_no_mem;
	ar_dFaultScores_Set[1] = ar_dFaultScores_control;
	ar_dFaultScores_Set[2] = ar_dFaultScores_address;
	ar_dFaultScores_Set[3] = ar_dFaultScores_data;
	ar_dFaultScores_Set[4] = ar_dFaultScores_data_random;
	ar_dFaultScores_Set[5] = ar_dFaultScores_data_huge;
	
	while((opt=getopt_long(argc,argv,"chvfqn:",long_args,&option_index)) != -1)
	{
		switch(opt)
		{
			/* other long options ? */
			case 0:
				break;
			/* Version */
			case 2:
				printf("%d.%d.%d",	V2MEMTEST__VERSION__MAJOR,
									V2MEMTEST__VERSION__MINOR,
									V2MEMTEST__VERSION__PATCH);
				bQuit = true;
				break;
			/* TMU0 long options */
			case 3:
			/* TMU1 long options */ 
			case 1:
				{
					def_eTMURamLimit newRAMLimit;
					switch(strtol(optarg, NULL, 10))
					{
						case -1: 	newRAMLimit = E_TMU_RAMSIZE__AUTO; break;
						case 1: 	newRAMLimit = E_TMU_RAMSIZE__1MB; break;
						case 2: 	newRAMLimit = E_TMU_RAMSIZE__2MB; break;
						case 3: 	newRAMLimit = E_TMU_RAMSIZE__3MB; break;
						case 4: 	newRAMLimit = E_TMU_RAMSIZE__4MB; break;
						default:
							Status = E_ERROR__BAD_ARGUMENT_VALUE;
							ErrorCheck_gotoCleanUp();
							break;
					}
					if(opt==3) 	sOptions.eTMU0RamLimit = newRAMLimit;
					else 		sOptions.eTMU1RamLimit = newRAMLimit;
				}
				break;
				
			case '?':
				puts(szHelp);
				Status = E_ERROR__UNKNOWN_ARGUMENT;
				ErrorCheck_gotoCleanUp();
				break;
			case 'q':
				sOptions.bQuick = true;
				break;
			case 'c':
				sOptions.bContinue = true;
				break;
			case 'f':
				sOptions.bForce = true;
				break;
			case 'h':
				puts(szHelp);
				bQuit = true;
				break;
				
			case 'n':
				sOptions.lNumLoops =	strtol(optarg, NULL, 10);
				if( sOptions.lNumLoops < 0 )
				{
					Status = E_ERROR__BAD_ARGUMENT_VALUE;
					ErrorCheck_gotoCleanUp();
				}
				break;
				
			case 'v':
				if(sOptions.eLogLevel < E_LOGLEVEL__TRACE)
					sOptions.eLogLevel++;
				break;
				
			default:
				Status = E_ERROR__UNKNOWN_ERROR;
				ErrorCheck_gotoCleanUp();
				break;
		}
	}
	
	if(bQuit)
		return 0;
	
	if(!sOptions.bTestTMU0 && !sOptions.bTestTMU1)
	{
		sOptions.bTestTMU0 = true;
		sOptions.bTestTMU1 = true;
	}
	
	if(	!sOptions.bTestTMUAddress && 
		!sOptions.bTestTMUData && 
		!sOptions.bTestTMUDataHuge &&
		!sOptions.bTestTMUControl&&
		!sOptions.bTestNoMem)
	{
		sOptions.bTestTMUControl	= true;
		sOptions.bTestTMUAddress	= true;
		sOptions.bTestTMUData		= true;
		sOptions.bTestTMUDataHuge	= true;
		sOptions.bTestNoMem			= true;
	}
	
	sst1DeviceInfoStruct devInfo;
	memset(&devInfo,0,sizeof(sst1DeviceInfoStruct));
	
	SstRegs *sstregs = NULL;
	
	logI(szTitle,	V2MEMTEST__VERSION__MAJOR,
					V2MEMTEST__VERSION__MINOR,
					V2MEMTEST__VERSION__PATCH);
	logI("\n");
	logI(szLicence);
	logI("\n");
	
	srandom(time(NULL));
	
	FaultSource_reset(ar_dFaultScores_no_mem);
	FaultSource_reset(ar_dFaultScores_control);
	FaultSource_reset(ar_dFaultScores_address);
	FaultSource_reset(ar_dFaultScores_data);
	FaultSource_reset(ar_dFaultScores_data_random);
	FaultSource_reset(ar_dFaultScores_data_huge);
	FaultSource_reset(ar_dFaultScores_ALL);
	FaultSource_reset(ar_dFaultScores_sorted);
	
	for(long j=0; j < sOptions.lNumLoops; j++) 
	{
		logI("# processing loop %ld of %ld\n",j+1,sOptions.lNumLoops);
		if ((sst = sst1InitMapBoard(boardNum)) == NULL)
		{
			logE("no Voodoo boards found\n");
			Status = E_ERROR__SST1_INIT;
			ErrorCheck_gotoCleanUp();
		}
		
		sst1InitRegisters(sst);
		sstregs = (SstRegs *) sst;
		
		if (sst1InitGetDeviceInfo(sst, &devInfo) == FXFALSE)
		{
			logE("couldn't get info for Voodoo # %d\n", boardNum);
			Status = E_ERROR__SST1_GET_INFO;
			ErrorCheck_gotoCleanUp();
		}
		
		/* Enabling video output so the Board will 
		* be configured automatically (FIFO, GRXCLK...)*/
		sst1InitVideo(sst,GR_RESOLUTION_800x600,GR_REFRESH_60Hz,0);
		
		logI("FBI detected memory:\t%ld MB\n", (unsigned long)devInfo.fbiMemSize);
		if(devInfo.fbiMemSize < 2)
		{
			logE("couldn't test Voodoo2 TMUs without minimum 2MB of FBI memory\n");
			Status = E_ERROR__NOT_ENOUGH_FBI_RAM;
			ErrorCheck_gotoCleanUp();
		}
		
		if(devInfo.numberTmus>2) //FixMe: This case can happen if U8_TMU1_TF_DATA_9 is wrong
		{
			logE("Only 2 TMUs are supported\n");
			if(sOptions.bForce)
			{
				logW("Forcing one TMU");
				devInfo.numberTmus = 1;
			}
			else
			{
				Status = E_ERROR__WRONG_TMU_SELECTED;
				ErrorCheck_gotoCleanUp();
			}
		}
		
		for (int tmu = 0; tmu <  devInfo.numberTmus; tmu++)
			logI("TMU%d detected memory:\t%ld MB\n", tmu, (unsigned long)devInfo.tmuMemSize[tmu]);
		
		if((sOptions.eTMU0RamLimit >= 0) && (devInfo.numberTmus>=1))
			devInfo.tmuMemSize[0] = sOptions.eTMU0RamLimit;
		if((sOptions.eTMU1RamLimit >= 0) && (devInfo.numberTmus==2))
			devInfo.tmuMemSize[1] = sOptions.eTMU1RamLimit;
			
		for (int tmu = 0; tmu <  devInfo.numberTmus; tmu++)
			logI("TMU%d tested memory:\t%ld MB\n", tmu, (unsigned long)devInfo.tmuMemSize[tmu]);
			
		putchar('\n');
		
		if(sOptions.bTestTMU0 && devInfo.numberTmus<1)
		{
			logE("TMU0 not Found\n");
			if(sOptions.bForce)
			{
				logW("Forcing TMU0 test");
			}
			else
			{
				Status = E_ERROR__TMU_NOT_FOUND;
				ErrorCheck_gotoCleanUp();
			}
		}
		
		if(sOptions.bTestTMU1 && devInfo.numberTmus<2)
		{
			logE("TMU1 not Found\n");
			if(sOptions.bForce)
			{
				logW("Forcing TMU1 test");
			}
			else
			{
				Status = E_ERROR__TMU_NOT_FOUND;
				ErrorCheck_gotoCleanUp();
			}
		}
		
		const bool bTestTMU0 	=   (  (devInfo.numberTmus > 0)
									|| sOptions.bForce)
									&& sOptions.bTestTMU0;
		
		const bool bTestTMU1 	=   (  (devInfo.numberTmus > 1)
									|| sOptions.bForce)
									&& sOptions.bTestTMU1;
		if(!bTestTMU0 && !bTestTMU1)
		{
			logE("no TMU selected.\n");
			Status = E_ERROR__NO_TMU_SELECTED;
			ErrorCheck_gotoCleanUp();
		}
		if(bTestTMU1 && !bTestTMU0)
		{
			logW("/!\\ make sure you did test TMU0 BEFORE TMU1.\n\n");
		}
		
		ISET(sstregs->lfbMode, 
				  SST_LFB_RGBALANES_ARGB 
				| SST_LFB_READFRONTBUFFER);
				
		ISET(sstregs->fbzMode, 
				  SST_DRAWBUFFER_FRONT 
				| SST_RGBWRMASK); // <-for NoMEM test
				
		ISET(	sstregs->fbzColorPath,
				  SST_RGBSEL_TMUOUT
				| SST_ASEL_TMUOUT // <-for NoMEM test
				| SST_ENTEXTUREMAP);
				
		for (int tmu = 0; tmu <  devInfo.numberTmus; tmu++)
		{
			ISET(	SST_TREX(sstregs,tmu)->textureMode, 
					SST_RGB565 
					| SST_TC_REPLACE 
					| SST_TCA_REPLACE);
		}
		ISET(sstregs->tLOD, 0);

		for (int tmu = 0; tmu <  devInfo.numberTmus; tmu++)
		{
			if((tmu == 0) && !bTestTMU0) continue;
			if((tmu == 1) && !bTestTMU1) continue;
			
			logI("## testing Board %d, TMU %d, %ldMB \n",
			boardNum,tmu,(unsigned long)devInfo.tmuMemSize[tmu]);

			if(sOptions.bTestNoMem)
			{
				unsigned long long err=0;
				
				if(!sOptions.bQuick)
				{
					logI("### pre-heating\n");
					HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
				}
				
				logI("### data test - no mem\n");
				clearScreen(sstregs, 0x00000000, 256, 256);
				
				clock_t test_begin = clock();
				do
				{	
					err = test_TMU_datalines_NoMem(	&devInfo,
													sst,
													sstregs,
													tmu ,
													ar_dFaultScores_no_mem);
					ullNbErrorAll += err;
					logI( err ? "E" : ".");
					fflush(stdout);
				}
				while(	(!err || sOptions.bContinue) &&
						(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
							< _DEF_TEST_TIME_PER_MB_S));
				
				logI("\n");
				FaultSource_nomalize(ar_dFaultScores_no_mem);
				
				if(err)
				{
					logW("error detected on TMUs tex lines (no-mem test) !\n");
					if(!sOptions.bContinue)
					{
						logW("skiping next tests.\n\n");
						continue;
					}
				}
			}
			logI("\n");
			
			ISET(sstregs->lfbMode, 
				  SST_LFB_RGBALANES_ARGB 
				| SST_LFB_READFRONTBUFFER);
	
			if(sOptions.bTestTMUControl && (devInfo.tmuMemSize[tmu]>0))
			{
				unsigned long long err=0;
				
				if(!sOptions.bQuick)
				{
					logI("### pre-heating\n");
					HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
				}
				
				logI("### control lines test - simple\n");
				clearScreen(sstregs, 0x00000000, 256, 256);
				
				clock_t test_begin = clock();
				int i=0;
				do
				{
					err = TestControl(&devInfo,
											sst,
											sstregs,
											tmu,
											devInfo.tmuMemSize[tmu],
											ar_dFaultScores_control);
					ullNbErrorAll += err;
					if(err || (((i++)%1000)==0))
					{
						logI( err ? "E" : ".");
						fflush(stdout);
					}
				}
				while(	(!err || sOptions.bContinue) &&
						(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
							< _DEF_TEST_TIME_PER_MB_S));
				
				logI("\n");
				FaultSource_nomalize(ar_dFaultScores_control);
				if(err)
				{
					logW("error detected on control line !\n");
					if(!sOptions.bContinue)
					{
						logW("skiping next tests.\n\n");
						continue;
					}
				}
			}
			
			if(sOptions.bTestTMUAddress  && (devInfo.tmuMemSize[tmu]>0))
			{
				unsigned long long err=0;
				
				if(!sOptions.bQuick)
				{
					logI("### pre-heating\n");
					HeatMemAndTMU(&devInfo, sst, sstregs, tmu,0x000000);
				}
				
				logI("### address lines test - cumulated\n");
				clearScreen(sstregs, 0x00000000, 256, 256);
				
				clock_t test_begin = clock();
				int i=0;
				do
				{	
					err = 0;
					for(	unsigned char stepMemSize=1;
							(stepMemSize <= devInfo.tmuMemSize[tmu]) && !err;
							stepMemSize++)
					{
						err = RenderTestAddress(&devInfo,
												sst,
												sstregs,
												tmu,
												stepMemSize,
												ar_dFaultScores_address);
						ullNbErrorAll += err;
						if(err || (((i++)%28)==0))
						{
							logI( err ? "E" : ".");
							fflush(stdout);
						}
					}
				}
				while(	(!err || sOptions.bContinue) &&
						(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
							< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
				
				logI("\n");
				FaultSource_nomalize(ar_dFaultScores_address);
				if(err)
				{
					logW("error detected on address line !\n");
					if(!sOptions.bContinue)
					{
						logW("skiping next tests.\n\n");
						continue;
					}
				}
			}
			
			if(sOptions.bTestTMUData  && (devInfo.tmuMemSize[tmu]>0))
			{
				unsigned long long err=0;
				
				if(!sOptions.bQuick)
				{
					logI("### pre-heating\n");
					HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
				}
				
				logI("### data test - single bit move\n");
				clearScreen(sstregs, 0x00000000, 256, 256);
				
				clock_t test_begin = clock();
				do
				{	
					err = test_TMU_datalines(&devInfo,
											sst,
											sstregs,
											tmu ,
											0, /* bit shift mode */
											devInfo.tmuMemSize[tmu],
											ar_dFaultScores_data);
					ullNbErrorAll += err;
					logI( err ? "E" : ".");
					fflush(stdout);
				}
				while(  (!err || sOptions.bContinue) &&
						(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
							< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
				
				logI("\n");
				FaultSource_nomalize(ar_dFaultScores_data);
				if(err)
				{
					logW("error detected on data line (single bit move) !\n");
					if(!sOptions.bContinue)
					{
						logW("skiping next tests.\n\n");
						continue;
					}
				}
				
				if(!sOptions.bQuick)
				{
					logI("### pre-heating\n");
					HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
				}
				
				logI("### data test - random patterns\n");
				clearScreen(sstregs, 0x00000000, 256, 256);
				
				test_begin = clock();
				do
				{	
					err = test_TMU_datalines(&devInfo,
											sst,
											sstregs,
											tmu ,
											1, /* random mode */
											devInfo.tmuMemSize[tmu],
											ar_dFaultScores_data_random);
					ullNbErrorAll += err;
					logI( err ? "E" : ".");
					fflush(stdout);
				}
				while(	(!err || sOptions.bContinue) &&
						(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
						< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
				
				logI("\n");
				FaultSource_nomalize(ar_dFaultScores_data_random);
				if(err)
				{
					logW("error detected on data line (random patterns) !\n");
					if(!sOptions.bContinue)
					{
						logW("skiping next tests.\n\n");
						continue;
					}
				}
			}
			
			if(sOptions.bTestTMUDataHuge && (devInfo.tmuMemSize[tmu]>0))
			{
				unsigned long long err=0;
				
				if(!sOptions.bQuick)
				{
					logI("### pre-heating\n");
					HeatMemAndTMU(&devInfo, sst, sstregs, tmu, 0x000000);
				}
				
				logI("### data test - huge data set\n");
				clearScreen(sstregs, 0x00000000, 256, 256);
				
				clock_t test_begin = clock();
				do
				{	
					err = test_TMU_datalines_Huge(	&devInfo,
													sst,
													sstregs,
													tmu ,
													devInfo.tmuMemSize[tmu],
													ar_dFaultScores_data_huge);
					ullNbErrorAll += err;
					logI( err ? "E" : ".");
					fflush(stdout);
				}
				while(	(!err || sOptions.bContinue) &&
						(((double)(clock() - test_begin)/CLOCKS_PER_SEC)
							< (devInfo.tmuMemSize[tmu]*_DEF_TEST_TIME_PER_MB_S)));
				
				logI("\n");
				FaultSource_nomalize(ar_dFaultScores_data_huge);
				if(err)
				{
					logW("error detected on data line (huge data set) !\n");
					if(!sOptions.bContinue)
					{
						logW("skiping next tests.\n\n");
						continue;
					}
				}
			}
			logI("\n");
		}
		
		sst1InitShutdown(sst);
		sst = NULL;
	}
	 
	FaultSource_sum(ar_dFaultScores_Set,
					uNb_dFaultScores_Set,
					ar_dFaultScores_ALL);
	FaultSource_getSorted(ar_dFaultScores_sorted,ar_dFaultScores_ALL);
	FaultSource_nomalize(ar_dFaultScores_sorted);
	FaultSource_divideAll(ar_dFaultScores_sorted,0.01);
	FaultSource_display(ar_dFaultScores_sorted);
	
	logI("test completed, ullNbErrorAll = %lld\n",ullNbErrorAll);
	logI("\n");
	if(ullNbErrorAll)
		logI(szKool);
	else
		logI(szKool2);
	logI("\n");
	
CleanUp:
	if(sst)
		sst1InitShutdown(sst);
	return Status;
}