bool testCacheExample() {
char* empty_string = "";
char* hello = "Hello world!";
char* helloAgain = "Hello world!";
char* goodbye = "Goodbye!";
char* goodDay = "Good day!";
Cache cache = cacheCreate(256, freeString, copyString, compareStrings, getFirstLetter);
ASSERT_TEST(cache != NULL);
ASSERT_TEST(cacheIsIn(cache, hello) == false);
ASSERT_TEST(cachePush(cache, hello) == CACHE_SUCCESS);
ASSERT_TEST(cacheIsIn(cache, helloAgain) == true);
ASSERT_TEST(cachePush(cache, hello) == CACHE_ITEM_ALREADY_EXISTS);
ASSERT_TEST(cachePush(cache, goodbye) == CACHE_SUCCESS);
ASSERT_TEST(cachePush(cache, goodDay) == CACHE_SUCCESS);
ASSERT_TEST(cachePush(cache, empty_string) == CACHE_SUCCESS);
ASSERT_TEST(cacheIsIn(cache, empty_string) == true);
ASSERT_TEST(cacheIsIn(cache, goodbye) == true);
char* temp_ptr;
temp_ptr = cacheExtractElementByKey(cache, 0);
ASSERT_TEST(strcmp(temp_ptr, "") == 0);
ASSERT_TEST(cacheIsIn(cache, empty_string) == false);
ASSERT_TEST(cacheFreeElement(cache, goodbye) == CACHE_SUCCESS);
ASSERT_TEST(cacheIsIn(cache, goodbye) == false);
ASSERT_TEST(cacheClear(cache) == CACHE_SUCCESS);
ASSERT_TEST(setGetFirst(cacheGetFirst(cache)) == NULL);
free(temp_ptr);
cacheDestroy(cache);
return true;
}
ThreadState::ThreadState(ProcessState &WithParent,
seec::trace::ThreadState &ForState)
: Parent(WithParent),
UnmappedState(ForState),
CallStack()
{
cacheClear();
}
// -------------------------------------------------------------------------------------------
void UnPackX::setCurrentEvent(u_int eventNumber)
{
if (eventNumber==0xffffffff) return;
cacheClear();
if ((eventNumber>=firstEvent) && (eventNumber<=lastEvent)) {
currentEvent=eventNumber;
currentIndexStruct=indexList[eventNumber-firstEvent];
return;
}
cout << "UnPackX::setCurrentEvent: Corrupt event number: "<< eventNumber << endl;
}
UnPackX::~UnPackX(){
cacheClear();
dataFile->close();
delete dataFile; dataFile=NULL;
delete runHeader; runHeader=NULL;
delete moduleHeader; moduleHeader=NULL;
delete eventHeader; eventHeader=NULL;
delete infoHeader; infoHeader=NULL;
delete indexHeader; indexHeader=NULL;
delete beamHeader; beamHeader=NULL;
delete hivoHeader; hivoHeader=NULL;
}
CCacheManager::~CCacheManager()
{
delete []avability_L00_L03;
delete []avability_L04_L08;
delete []avability_L09_L13;
delete []avability_SRTM;
delete []avabilityTex_L00_L02;
delete []avabilityTex_L03_L05;
delete []avabilityTex_L06_L08;
delete []avabilityTex_L09_L10;
delete []stripIndexListNW;
delete []stripIndexListNE;
delete []stripIndexListSW;
delete []stripIndexListSE;
cacheClear(0); // drop all unused terrains
delete []cachedTerrainDataGroup_L00_L03;
delete []cachedTerrainDataGroup_L04_L08;
delete []cachedTerrainDataGroup_L09_L13;
instance = 0;
}
/*异步链式EDMA传输，上层模块注册中断处理程序，处理EDMA传输完成事件*/
s32 edmac_test_async_lli(enum edma_req_id req, u32 direction)
{
edma_addr_t edma_addr = 0;
s32 ret_id = 0;
s32 ret = 0;
u32 i = 0;
struct edma_cb *pstNode = NULL;
struct edma_cb *psttemp = NULL;
struct edma_cb *FirstNode = NULL;
edma_buff_init();
/*创建链表*/
pstNode = (struct edma_cb *)dma_alloc_coherent(NULL,(EDMA_TEST_LLI_NUM * sizeof(struct edma_cb)),
&edma_addr, GFP_DMA|__GFP_WAIT);
s_edma_alloc_address.s_alloc_virt_address = (u32)pstNode;
s_edma_alloc_address.s_alloc_phys_address = (u32)edma_addr;
if (NULL == pstNode)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"LII list init is failed!");
edma_buff_exit();
return EDMA_MEMORY_ALLOCATE_ERROR;
}
FirstNode = pstNode;
psttemp = pstNode;
for (i = 0; i < EDMA_TEST_LLI_NUM; i++)
{
psttemp->lli = EDMA_SET_LLI(edma_addr + (i+1) * sizeof(struct edma_cb), ((i < EDMA_TEST_LLI_NUM - 1)?0:1));
psttemp->config = stDmaLLI[i].ulConfig;
psttemp->src_addr = stDmaLLI[i].ulSourAddr;
psttemp->des_addr = stDmaLLI[i].ulDestAddr;
psttemp->cnt0 = stDmaLLI[i].ulLength;
psttemp->bindx = 0;
psttemp->cindx = 0;
psttemp->cnt1 = 0;
psttemp++;
}
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"LII list init is success!");
/*申请通道，注册通道中断回调函数*/
ret_id = bsp_edma_channel_init(req, (channel_isr)edma_isr_sema_give, 0, EDMA_INT_DONE);
if (ret_id < 0)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"---------ERROR ret_id = 0x%X\n\n",ret_id);
return EDMA_CHANNEL_INVALID;
}
/*获取首节点寄存器地址*/
psttemp = bsp_edma_channel_get_lli_addr((u32)ret_id);
if (NULL == psttemp)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"---bsp_edma_channel_get_lli_addr FAILED !\n\n");
bsp_edma_channel_free((u32)ret_id);
return EDMA_CHANNEL_INVALID;
}
/*配置首节点寄存器*/
psttemp->lli = FirstNode->lli;
psttemp->config = FirstNode->config & 0xFFFFFFFE;
psttemp->src_addr = FirstNode->src_addr; /*物理地址*/
psttemp->des_addr = FirstNode->des_addr; /*物理地址*/
psttemp->cnt0 = FirstNode->cnt0;
psttemp->bindx = 0;
psttemp->cindx = 0;
psttemp->cnt1 = 0;
/* * */
cacheClear( DATA_CACHE, (void*)edma_buf_phys, (EDMA_TEST_LLI_NUM + 2) * EDMA_TEST_LLI_BLOCK_SIZE );
/*启动EDMA传输后即返回，可通过查询通道是否busy来确定传输是否完成*/
if (bsp_edma_channel_lli_async_start((u32)ret_id))
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"bsp_edma_channel_lli_async_start FAILED!\n\n");
dma_free_coherent(NULL,(EDMA_TEST_LLI_NUM * sizeof(struct edma_cb)),
(void*)s_edma_alloc_address.s_alloc_virt_address, edma_addr);
edma_buff_exit();
bsp_edma_channel_free((u32)ret_id);
return EDMA_TRXFER_ERROR;
}
while(0==bsp_edma_channel_is_idle((u32) ret_id))
{printf("a");}
printf("\n");
/*mdelay(200);*/
bsp_edma_channel_free((u32)ret_id);
/* Verify the transfer data */
for( i = 0; i < EDMA_TEST_LLI_NUM; i++ )
{
u8* temp_dest = pucDest + i * EDMA_TEST_LLI_BLOCK_SIZE;
ret = edma_verify_data( temp_dest, EDMA_TEST_LLI_BLOCK_SIZE, (i & 0x1) ? 0x3a : 0x6 );
if( !ret )
{
break;
}
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"\rFirst Verify, d[0]=0x%X, d[1]=0x%X, d[2]=0x%X, d[3]=0x%X, d[4]=0x%X, d[5]=0x%X\r\n ",
*((u8 *)temp_dest + 0 ),
*((u8 *)temp_dest + 1 ),
*((u8 *)temp_dest + 2 ),
*((u8 *)temp_dest + 3 ),
*((u8 *)temp_dest + 4 ),
*((u8 *)temp_dest + 5 ) );
}
dma_free_coherent(NULL,(EDMA_TEST_LLI_NUM * sizeof(struct edma_cb)),
(void*)s_edma_alloc_address.s_alloc_virt_address, edma_addr);
edma_buff_exit();
if (ret)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"bsp_edma_channel_lli_start FAILED!\n");
return EDMA_TRXFER_ERROR;
}
hiedmac_trace(BSP_LOG_LEVEL_CRIT,"===============EDMA_LLI_ASYNC_START_SUCCESS!\n");
return EDMA_SUCCESS;
}
/*M2M sync LLI EDMA trans . wait for the completion sem, do not need int handler */
s32 edmac_test_lli(enum edma_req_id req, u32 direction)
{
edma_addr_t edma_addr = 0;
s32 ret_id = 0;
s32 ret = 0;
u32 i = 0;
struct edma_cb *pstNode = NULL;
struct edma_cb *psttemp = NULL;
struct edma_cb *FirstNode = NULL;
edma_buff_init();
/*build lli */
pstNode = (struct edma_cb *)dma_alloc_coherent(NULL,(EDMA_TEST_LLI_NUM * sizeof(struct edma_cb)),
&edma_addr, GFP_DMA|__GFP_WAIT);
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"---------------edma_addr = 0x%X\n",edma_addr);
s_edma_alloc_address.s_alloc_virt_address = (u32)pstNode;
s_edma_alloc_address.s_alloc_phys_address = (u32)edma_addr;
if (NULL == pstNode)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"LLI list init is failed!\n");
edma_buff_exit();
return EDMA_MEMORY_ALLOCATE_ERROR;
}
FirstNode = pstNode;
psttemp = pstNode;
for (i = 0; i < EDMA_TEST_LLI_NUM; i++)
{
psttemp->lli = EDMA_SET_LLI(edma_addr + (i+1) * sizeof(struct edma_cb), ((i < EDMA_TEST_LLI_NUM - 1)?0:1));
psttemp->config = stDmaLLI[i].ulConfig;
psttemp->src_addr = stDmaLLI[i].ulSourAddr;/*physical address*/
psttemp->des_addr = stDmaLLI[i].ulDestAddr;/*physical address*/
psttemp->cnt0 = stDmaLLI[i].ulLength;
psttemp->bindx = 0;
psttemp->cindx = 0;
psttemp->cnt1 = 0;
psttemp++;
}
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"LII list init is success!\n");
/*request the chan_id, and init the sem*/
ret_id = bsp_edma_channel_init(req, NULL, 0, 0);
if (ret_id < 0)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"-----------error ret_id = 0x%X\n\n",ret_id);
return EDMA_CHANNEL_INVALID;
}
/*获取首节点寄存器地址*/
psttemp = bsp_edma_channel_get_lli_addr((u32)ret_id);
if (NULL == psttemp)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"---bsp_edma_channel_get_lli_addr failed!\n\n");
bsp_edma_channel_free((u32)ret_id);
return EDMA_CHANNEL_INVALID;
}
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"----------- edma_cb LLI = 0x%X!\n\n",(u32)psttemp);
/*配置首节点寄存器*/
psttemp->lli = FirstNode->lli;
psttemp->config = FirstNode->config & 0xFFFFFFFE;
psttemp->src_addr = FirstNode->src_addr;
psttemp->des_addr = FirstNode->des_addr;
psttemp->cnt0 = FirstNode->cnt0;
psttemp->bindx = 0;
psttemp->cindx = 0;
psttemp->cnt1 = 0;
/* * */
cacheClear( DATA_CACHE, (void*)edma_buf_phys, (EDMA_TEST_LLI_NUM + 2) * EDMA_TEST_LLI_BLOCK_SIZE );
/*启动EDMA传输，等待传输完成信号量释放后返回*/
if (bsp_edma_channel_lli_start((u32)ret_id))
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"bsp_edma_channel_lli_start FAILED!\n\n");
dma_free_coherent(NULL,(EDMA_TEST_LLI_NUM * sizeof(struct edma_cb)),
(void*)s_edma_alloc_address.s_alloc_virt_address, edma_addr);
edma_buff_exit();
bsp_edma_channel_free((u32)ret_id);
return EDMA_TRXFER_ERROR;
}
taskDelay(10);
while(0==bsp_edma_channel_is_idle((u32) ret_id))
{printf("a");}
printf("a\n");
/* Verify the transfer data */
for( i = 0; i < EDMA_TEST_LLI_NUM; i++ )
{
u8* temp_dest = pucDest + i * EDMA_TEST_LLI_BLOCK_SIZE;
ret = edma_verify_data( temp_dest, EDMA_TEST_LLI_BLOCK_SIZE, (i & 0x1) ? 0x3a : 0x6 );
if( !ret )
{
break;
}
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"\rFirst Verify, d[0]=0x%X, d[1]=0x%X, d[2]=0x%X, d[3]=0x%X, d[4]=0x%X, d[5]=0x%X\r\n ",
*((u8 *)temp_dest + 0 ),
*((u8 *)temp_dest + 1 ),
*((u8 *)temp_dest + 2 ),
*((u8 *)temp_dest + 3 ),
*((u8 *)temp_dest + 4 ),
*((u8 *)temp_dest + 5 ));
}
/*保证传完数据以后再释放内存*/
dma_free_coherent(NULL,(EDMA_TEST_LLI_NUM * sizeof(struct edma_cb)),
(void*)s_edma_alloc_address.s_alloc_virt_address, edma_addr);
edma_buff_exit();
bsp_edma_channel_free((u32)ret_id);
if (ret)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"bsp_edma_channel_lli_start FAILED!\n\n");
return EDMA_TRXFER_ERROR;
}
hiedmac_trace(BSP_LOG_LEVEL_CRIT,"=============== EDMA_LLI_START_SUCCESS!\n");
return EDMA_SUCCESS;
}
/*异步EDMA传输，上层模块查询EDMA传输是否结束*/
s32 edmac_test_channel_async(enum edma_req_id req, u32 direction)
{
s32 ret_id = 0;
u32 bur_width = 2;
u32 bur_len = 3;
u32 ask_is_idle_loop = 0;
u32 byte_len = EDMA_M2M_TEST_LENGHT;
char *temp = NULL;
s32 count = 0;
if ((NULL == src_buf) || (NULL == des_buf))
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"-----------edma test not inited \n\n");
return EDMA_FAIL;
}
temp = src_buf;
while (count < EDMA_M2M_TEST_LENGHT)
{
*temp++ = 'a' + count%20;
++count;
}
src_buf[EDMA_M2M_TEST_LENGHT - 1]='\0';
temp = des_buf;
count = 0;
while (count < EDMA_M2M_TEST_LENGHT)
{
*temp++ = 'c' + count%20;
++count;
}
des_buf[EDMA_M2M_TEST_LENGHT - 1]='\0';
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"---src_buf =%c%c%c%c%c%c%c\n", *((char*)src_buf + 0),
*((char*)src_buf + 1), *((char*)src_buf + 2), *((char*)src_buf + 3),
*((char*)src_buf + 4), *((char*)src_buf + 5), *((char*)src_buf + 6));
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"---des_buf =%c%c%c%c%c%c%c\n", *((char*)des_buf + 0),
*((char*)des_buf + 1), *((char*)des_buf + 2), *((char*)des_buf + 3),
*((char*)des_buf + 4), *((char*)des_buf + 5), *((char*)des_buf + 6));
ret_id = bsp_edma_channel_init(req, NULL, 0, 0);
if (ret_id < 0)
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"-----------ERROE ret_id = 0x%X\n\n",ret_id);
return EDMA_CHANNEL_INVALID;
}
/* set config reg */
if (bsp_edma_channel_set_config((u32)ret_id, direction, bur_width, bur_len))
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"----------bsp_edma_channel_set_config FAILED!\n\n");
bsp_edma_channel_free((u32)ret_id);
return EDMA_CONFIG_ERROR;
}
/* ** */
cacheClear( DATA_CACHE, (void*)edma_src_addr, EDMA_M2M_TEST_LENGHT * sizeof(char*));
cacheClear( DATA_CACHE, (void*)edma_des_addr, EDMA_M2M_TEST_LENGHT * sizeof(char*));
if (bsp_edma_channel_async_start((u32)ret_id, (u32)edma_src_addr, (u32)edma_des_addr, byte_len))
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"----------bsp_edma_channel_async_start FAILED!\n\n");
bsp_edma_channel_free((u32)ret_id);
return EDMA_CONFIG_ERROR;
}
while(0==bsp_edma_channel_is_idle((u32) ret_id))
{printf("a");}
printf("\n");
bsp_edma_channel_free((u32)ret_id);
for (;;)
{
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"---------------pool channel async start!");
if (!bsp_edma_channel_is_idle((u32)ret_id))
{
ask_is_idle_loop++;
/*ssleep(2);*/
if (ask_is_idle_loop < 0x100000)
{
continue;
}
else
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"----------edma_trans_complete is TIMEOUT!");
return EDMA_TRXFER_ERROR;
}
}
else
{
hiedmac_trace(BSP_LOG_LEVEL_DEBUG,"edma_trans_complete-----ask_is_idle_loop=0x%X!\n\n",ask_is_idle_loop);
if (edmac_verify_data_blk(src_buf,des_buf))
{
hiedmac_trace(BSP_LOG_LEVEL_ERROR,"----------EDMA_CHANNEL_ASYNC_TEST_FAILED! verify \n\n");
return EDMA_TRXFER_ERROR;
}
hiedmac_trace(BSP_LOG_LEVEL_CRIT,"===============EDMA_CHANNEL_ASYNC_TEST_SUCCESS!\n");
return EDMA_SUCCESS;
}
}
}
Config::Config(QWidget *parent,int index) : QDialog(parent)
{
programPath = qApp->applicationDirPath() + "/";
ui.setupUi(this);
ui.tabConfiguration->setCurrentIndex(index);
ui.radioManualProxy->setChecked(true);
QRegExpValidator *proxyValidator = new QRegExpValidator(this);
QRegExp validate("[0-9]*");
proxyValidator->setRegExp(validate);
ui.proxyPort->setValidator(proxyValidator);
// build language list and sort alphabetically
QStringList langs = findLanguageFiles();
for(int i = 0; i < langs.size(); ++i)
lang.insert(languageName(langs.at(i))
+ QString(" (%1)").arg(langs.at(i)), langs.at(i));
lang.insert(DEFAULT_LANG, DEFAULT_LANG_CODE);
QMap<QString, QString>::const_iterator i = lang.constBegin();
while (i != lang.constEnd()) {
ui.listLanguages->addItem(i.key());
i++;
}
ComboBoxViewDelegate *delegate = new ComboBoxViewDelegate(this);
ui.mountPoint->setItemDelegate(delegate);
#if !defined(DBG)
ui.mountPoint->setEditable(false);
#endif
ui.listLanguages->setSelectionMode(QAbstractItemView::SingleSelection);
ui.proxyPass->setEchoMode(QLineEdit::Password);
ui.treeDevices->setAlternatingRowColors(true);
ui.listLanguages->setAlternatingRowColors(true);
/* Explicitly set some widgets to have left-to-right layout */
ui.treeDevices->setLayoutDirection(Qt::LeftToRight);
ui.mountPoint->setLayoutDirection(Qt::LeftToRight);
ui.proxyHost->setLayoutDirection(Qt::LeftToRight);
ui.proxyPort->setLayoutDirection(Qt::LeftToRight);
ui.proxyUser->setLayoutDirection(Qt::LeftToRight);
ui.proxyPass->setLayoutDirection(Qt::LeftToRight);
ui.listLanguages->setLayoutDirection(Qt::LeftToRight);
ui.cachePath->setLayoutDirection(Qt::LeftToRight);
ui.comboTts->setLayoutDirection(Qt::LeftToRight);
this->setModal(true);
connect(ui.buttonOk, SIGNAL(clicked()), this, SLOT(accept()));
connect(ui.buttonCancel, SIGNAL(clicked()), this, SLOT(abort()));
connect(ui.radioNoProxy, SIGNAL(toggled(bool)), this, SLOT(setNoProxy(bool)));
connect(ui.radioSystemProxy, SIGNAL(toggled(bool)), this, SLOT(setSystemProxy(bool)));
connect(ui.refreshMountPoint, SIGNAL(clicked()), this, SLOT(refreshMountpoint()));
connect(ui.buttonAutodetect,SIGNAL(clicked()),this,SLOT(autodetect()));
connect(ui.buttonCacheBrowse, SIGNAL(clicked()), this, SLOT(browseCache()));
connect(ui.buttonCacheClear, SIGNAL(clicked()), this, SLOT(cacheClear()));
connect(ui.configTts, SIGNAL(clicked()), this, SLOT(configTts()));
connect(ui.configEncoder, SIGNAL(clicked()), this, SLOT(configEnc()));
connect(ui.comboTts, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTtsState(int)));
connect(ui.treeDevices, SIGNAL(itemSelectionChanged()), this, SLOT(updateEncState()));
connect(ui.testTTS,SIGNAL(clicked()),this,SLOT(testTts()));
connect(ui.showDisabled, SIGNAL(toggled(bool)), this, SLOT(showDisabled(bool)));
connect(ui.mountPoint, SIGNAL(editTextChanged(QString)), this, SLOT(updateMountpoint(QString)));
connect(ui.mountPoint, SIGNAL(currentIndexChanged(int)), this, SLOT(updateMountpoint(int)));
// delete this dialog after it finished automatically.
connect(this, SIGNAL(finished(int)), this, SLOT(deleteLater()));
setUserSettings();
setDevices();
}
