VSIArchiveFilesystemHandler::~VSIArchiveFilesystemHandler()
{
std::map<CPLString,VSIArchiveContent*>::const_iterator iter;
for( iter = oFileList.begin(); iter != oFileList.end(); ++iter )
{
VSIArchiveContent* content = iter->second;
int i;
for(i=0;i<content->nEntries;i++)
{
delete content->entries[i].file_pos;
CPLFree(content->entries[i].fileName);
}
CPLFree(content->entries);
delete content;
}
if( hMutex != NULL )
CPLDestroyMutex( hMutex );
hMutex = NULL;
}
static void OGRGMLDriverUnload(CPL_UNUSED GDALDriver* poDriver)
{
if( GMLReader::hMutex != NULL )
CPLDestroyMutex( GMLReader::hMutex );
GMLReader::hMutex = NULL;
}
static void HDF4UnloadDriver( GDALDriver * /* poDriver */ )
{
if( hHDF4Mutex != NULL )
CPLDestroyMutex(hHDF4Mutex);
hHDF4Mutex = NULL;
}
static void OGRNASDriverUnload(CPL_UNUSED GDALDriver* poDriver)
{
if( NASReader::hMutex != NULL )
CPLDestroyMutex( NASReader::hMutex );
NASReader::hMutex = NULL;
}
/** Setup the pool.
*
* @param nThreads Number of threads to launch
* @param pfnInitFunc Initialization function to run in each thread. May be NULL
* @param pasInitData Array of initialization data. Its length must be nThreads,
* or it should be NULL.
* @return true if initialization was successful.
*/
bool CPLWorkerThreadPool::Setup(int nThreads,
CPLThreadFunc pfnInitFunc,
void** pasInitData)
{
CPLAssert( nThreads > 0 );
hCond = CPLCreateCond();
if( hCond == nullptr )
return false;
bool bRet = true;
aWT.resize(nThreads);
for(int i=0;i<nThreads;i++)
{
aWT[i].pfnInitFunc = pfnInitFunc;
aWT[i].pInitData = pasInitData ? pasInitData[i] : nullptr;
aWT[i].poTP = this;
aWT[i].hMutex = CPLCreateMutexEx(CPL_MUTEX_REGULAR);
if( aWT[i].hMutex == nullptr )
{
nThreads = i;
aWT.resize(nThreads);
bRet = false;
break;
}
CPLReleaseMutex(aWT[i].hMutex);
aWT[i].hCond = CPLCreateCond();
if( aWT[i].hCond == nullptr )
{
CPLDestroyMutex(aWT[i].hMutex);
nThreads = i;
aWT.resize(nThreads);
bRet = false;
break;
}
aWT[i].bMarkedAsWaiting = FALSE;
// aWT[i].psNextJob = nullptr;
aWT[i].hThread =
CPLCreateJoinableThread(WorkerThreadFunction, &(aWT[i]));
if( aWT[i].hThread == nullptr )
{
nThreads = i;
aWT.resize(nThreads);
bRet = false;
break;
}
}
// Wait all threads to be started
while( true )
{
CPLAcquireMutex(hMutex, 1000.0);
int nWaitingWorkerThreadsLocal = nWaitingWorkerThreads;
if( nWaitingWorkerThreadsLocal < nThreads )
CPLCondWait(hCond, hMutex);
CPLReleaseMutex(hMutex);
if( nWaitingWorkerThreadsLocal == nThreads )
break;
}
if( eState == CPLWTS_ERROR )
bRet = false;
return bRet;
}
int main( int argc, char ** argv )
{
/* -------------------------------------------------------------------- */
/* Process arguments. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor(argc, &argv, 0);
if( argc < 1 )
exit(-argc);
int nThreadCount = 4;
bool bOpenInThreads = true;
for( int iArg = 1; iArg < argc; iArg++ )
{
if( iArg < argc-1 && EQUAL(argv[iArg], "-i") )
{
nIterations = atoi(argv[++iArg]);
}
else if( iArg < argc-1 && EQUAL(argv[iArg], "-oi") )
{
nOpenIterations = atoi(argv[++iArg]);
}
else if( iArg < argc-1 && EQUAL(argv[iArg], "-t") )
{
nThreadCount = atoi(argv[++iArg]);
}
else if( EQUAL(argv[iArg], "-lock_on_open") )
{
bLockOnOpen = true;
}
else if( EQUAL(argv[iArg], "-open_in_main") )
{
bOpenInThreads = false;
}
else if( pszFilename == nullptr )
{
pszFilename = argv[iArg];
}
else
{
printf("Unrecognized argument: %s\n", argv[iArg]);
Usage();
}
}
if( pszFilename == nullptr )
{
printf("Need a file to operate on.\n");
Usage();
exit(1);
}
if( nOpenIterations > 0 )
bLockOnOpen = false;
/* -------------------------------------------------------------------- */
/* Get the checksum of band1. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDS = nullptr;
GDALAllRegister();
for( int i = 0; i < 2; i++ )
{
hDS = GDALOpen( pszFilename, GA_ReadOnly );
if( hDS == nullptr )
exit( 1 );
nChecksum = GDALChecksumImage(GDALGetRasterBand(hDS, 1),
0, 0,
GDALGetRasterXSize(hDS),
GDALGetRasterYSize(hDS));
GDALClose(hDS);
}
printf(
"Got checksum %d, launching %d worker threads on %s, %d iterations.\n",
nChecksum, nThreadCount, pszFilename, nIterations);
/* -------------------------------------------------------------------- */
/* Fire off worker threads. */
/* -------------------------------------------------------------------- */
pGlobalMutex = CPLCreateMutex();
CPLReleaseMutex(pGlobalMutex);
nPendingThreads = nThreadCount;
std::vector<GDALDatasetH> aoDS;
for( int iThread = 0; iThread < nThreadCount; iThread++ )
{
hDS = nullptr;
if( !bOpenInThreads )
{
hDS = GDALOpen(pszFilename, GA_ReadOnly);
if( !hDS )
{
printf("GDALOpen() failed.\n");
exit(1);
}
aoDS.push_back(hDS);
}
if( CPLCreateThread(WorkerFunc, hDS) == -1 )
{
printf("CPLCreateThread() failed.\n");
exit(1);
}
}
while( nPendingThreads > 0 )
CPLSleep(0.5);
CPLDestroyMutex(pGlobalMutex);
for( size_t i = 0; i < aoDS.size(); ++i )
GDALClose(aoDS[i]);
printf("All threads complete.\n");
CSLDestroy(argv);
GDALDestroyDriverManager();
return 0;
}