ELocalizationServiceOperationCommandResult::Type FOneSkyLocalizationServiceProvider::Execute(const TSharedRef<ILocalizationServiceOperation, ESPMode::ThreadSafe>& InOperation, const TArray<FLocalizationServiceTranslationIdentifier>& InTranslationIds, ELocalizationServiceOperationConcurrency::Type InConcurrency, const FLocalizationServiceOperationComplete& InOperationCompleteDelegate)
{
if(!IsEnabled())
{
return ELocalizationServiceOperationCommandResult::Failed;
}
// Query to see if the we allow this operation
TSharedPtr<IOneSkyLocalizationServiceWorker, ESPMode::ThreadSafe> Worker = CreateWorker(InOperation->GetName());
if(!Worker.IsValid())
{
// this operation is unsupported by this source control provider
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("OperationName"), FText::FromName(InOperation->GetName()) );
Arguments.Add( TEXT("ProviderName"), FText::FromName(GetName()) );
FMessageLog("LocalizationService").Error(FText::Format(LOCTEXT("UnsupportedOperation", "Operation '{OperationName}' not supported by source control provider '{ProviderName}'"), Arguments));
return ELocalizationServiceOperationCommandResult::Failed;
}
// fire off operation
if(InConcurrency == ELocalizationServiceOperationConcurrency::Synchronous)
{
FOneSkyLocalizationServiceCommand* Command = new FOneSkyLocalizationServiceCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = false;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return ExecuteSynchronousCommand(*Command, InOperation->GetInProgressString(), true);
}
else
{
FOneSkyLocalizationServiceCommand* Command = new FOneSkyLocalizationServiceCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = true;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return IssueCommand(*Command, false);
}
}
shared_ptr<WorkerThread> WorkerManager::GetWorker()
{
if(InactiveWorkerExists()) {
return GetInactiveWorker();
} else {
return CreateWorker();
}
}
/****************************************************************************
* Function: ThreadPoolAddPersistent
*
* Description:
* Adds a long term job to the thread pool.
* Job will be run as soon as possible.
* Call will block until job is scheduled.
* Parameters:
* tp - valid thread pool pointer
* job-> valid ThreadPoolJob pointer with following fields
* func - ThreadFunction to run
* arg - argument to function.
* priority - priority of job.
* free_function - function to use when freeing argument
* Returns:
* 0 on success, nonzero on failure
* EOUTOFMEM not enough memory to add job.
* EMAXTHREADS not enough threads to add persistent job.
*****************************************************************************/
int ThreadPoolAddPersistent( ThreadPool *tp, ThreadPoolJob *job, int *jobId )
{
int tempId = -1;
ThreadPoolJob *temp = NULL;
assert( tp != NULL );
assert( job != NULL );
if( ( tp == NULL ) || ( job == NULL ) ) {
return EINVAL;
}
if( jobId == NULL ) {
jobId = &tempId;
}
*jobId = INVALID_JOB_ID;
ithread_mutex_lock( &tp->mutex );
assert( job->priority == LOW_PRIORITY ||
job->priority == MED_PRIORITY ||
job->priority == HIGH_PRIORITY );
// Create A worker if less than max threads running
if( tp->totalThreads < tp->attr.maxThreads ) {
CreateWorker( tp );
} else {
// if there is more than one worker thread
// available then schedule job, otherwise fail
if( tp->totalThreads - tp->persistentThreads - 1 == 0 ) {
ithread_mutex_unlock( &tp->mutex );
return EMAXTHREADS;
}
}
temp = CreateThreadPoolJob( job, tp->lastJobId, tp );
if( temp == NULL ) {
ithread_mutex_unlock( &tp->mutex );
return EOUTOFMEM;
}
tp->persistentJob = temp;
// Notify a waiting thread
ithread_cond_signal( &tp->condition );
// wait until long job has been picked up
while( tp->persistentJob != NULL ) {
ithread_cond_wait( &tp->start_and_shutdown, &tp->mutex );
}
*jobId = tp->lastJobId++;
ithread_mutex_unlock( &tp->mutex );
return 0;
}
void RBench::Start(BOOLEAN trace) {
// clock_t t1, t2, t3, t4;
TaskState *t;
Packet *workQ;
if (trace) InitTrace(); else tracing = FALSE;
InitScheduler();
// t1 = clock();
// printf("\nRichards benchmark: initializing...\n");
t = new TaskState; t->Running(); // Idler
CreateIdler(Idler, 0, NoWork, t);
workQ = new Packet(NoWork, Worker, WorkPacket); // Worker
workQ = new Packet(workQ , Worker, WorkPacket);
t = new TaskState; t->WaitingWithPacket();
CreateWorker(Worker, 1000, workQ, t);
workQ = new Packet(NoWork, DeviceA, DevicePacket); // HandlerA
workQ = new Packet(workQ , DeviceA, DevicePacket);
workQ = new Packet(workQ , DeviceA, DevicePacket);
t = new TaskState; t->WaitingWithPacket();
CreateHandler(HandlerA, 2000, workQ, t);
workQ = new Packet(NoWork, DeviceB, DevicePacket); // HandlerB
workQ = new Packet(workQ , DeviceB, DevicePacket);
workQ = new Packet(workQ , DeviceB, DevicePacket);
t = new TaskState; t->WaitingWithPacket();
CreateHandler(HandlerB, 3000, workQ, t);
t = new TaskState; t->Waiting(); // DeviceA
CreateDevice(DeviceA, 4000, NoWork, t);
t = new TaskState; t->Waiting(); // DeviceB
CreateDevice(DeviceB, 5000, NoWork, t);
// printf("starting...\n");
// t2 = clock();
Schedule();
// t3 = clock();
// printf("done.\n");
// printf("QueuePacketCount = %d, HoldCount = %d.\nThese results are %s",
// queuePacketCount, holdCount,
// (queuePacketCount == 23246 && holdCount == 9297) ?
// "correct." : "wrong!"
// );
if (! (queuePacketCount == 23246 && holdCount == 9297)) {
printf("error: richards results are incorrect\n");
}
// t4 = clock();
// printf("\nScheduler time = %g seconds, total time = %g\n",
// (double)(t3 - t2) / CLK_TCK,
// (double)(t4 - t1) / CLK_TCK);
}
/****************************************************************************
* Function: AddWorker
*
* Description:
* Determines whether or not a thread should be added
* based on the jobsPerThread ratio.
* Adds a thread if appropriate.
* Internal to Thread Pool.
* Parameters:
* ThreadPool* tp
*
*****************************************************************************/
static void AddWorker( ThreadPool *tp )
{
int jobs = 0;
int threads = 0;
assert( tp != NULL );
jobs = tp->highJobQ.size + tp->lowJobQ.size + tp->medJobQ.size;
threads = tp->totalThreads - tp->persistentThreads;
while( threads == 0 || (jobs / threads) >= tp->attr.jobsPerThread ) {
if( CreateWorker( tp ) != 0 ) {
return;
}
threads++;
}
}
/****************************************************************************
* Function: ThreadPoolSetAttr
*
* Description:
* Sets the attributes for the thread pool.
* Only affects future calculations.
* Parameters:
* tp - valid thread pool pointer
* attr - pointer to attributes, null sets attributes to default.
* Returns:
* 0 on success, nonzero on failure
* Returns INVALID_POLICY if policy can not be set.
*****************************************************************************/
int ThreadPoolSetAttr( ThreadPool *tp, ThreadPoolAttr *attr )
{
int retCode = 0;
ThreadPoolAttr temp;
int i = 0;
assert( tp != NULL );
if( tp == NULL ) {
return EINVAL;
}
ithread_mutex_lock( &tp->mutex );
if( attr != NULL ) {
temp = ( *attr );
} else {
TPAttrInit( &temp );
}
if( SetPolicyType( temp.schedPolicy ) != 0 ) {
ithread_mutex_unlock( &tp->mutex );
return INVALID_POLICY;
}
tp->attr = ( temp );
// add threads
if( tp->totalThreads < tp->attr.minThreads )
{
for( i = tp->totalThreads; i < tp->attr.minThreads; i++ ) {
if( ( retCode = CreateWorker( tp ) ) != 0 ) {
break;
}
}
}
// signal changes
ithread_cond_signal( &tp->condition );
ithread_mutex_unlock( &tp->mutex );
if( retCode != 0 ) {
// clean up if the min threads could not be created
ThreadPoolShutdown( tp );
}
return retCode;
}
int ThreadPoolAddPersistent(ThreadPool *tp, ThreadPoolJob *job, int *jobId)
{
int ret = 0;
int tempId = -1;
ThreadPoolJob *temp = NULL;
if (!tp || !job) {
return EINVAL;
}
if (!jobId) {
jobId = &tempId;
}
*jobId = INVALID_JOB_ID;
ithread_mutex_lock(&tp->mutex);
/* Create A worker if less than max threads running */
if (tp->totalThreads < tp->attr.maxThreads) {
CreateWorker(tp);
} else {
/* if there is more than one worker thread
* available then schedule job, otherwise fail */
if (tp->totalThreads - tp->persistentThreads - 1 == 0) {
ret = EMAXTHREADS;
goto exit_function;
}
}
temp = CreateThreadPoolJob(job, tp->lastJobId, tp);
if (!temp) {
ret = EOUTOFMEM;
goto exit_function;
}
tp->persistentJob = temp;
/* Notify a waiting thread */
ithread_cond_signal(&tp->condition);
/* wait until long job has been picked up */
while (tp->persistentJob)
ithread_cond_wait(&tp->start_and_shutdown, &tp->mutex);
*jobId = tp->lastJobId++;
exit_function:
ithread_mutex_unlock(&tp->mutex);
return ret;
}
int CMapFileIO::SaveMap(const CLevelMap &map, HANDLE hFile) const
{
XML_MANAGER_HANDLE xml = 0;
std::wostringstream os;
xml = CreateWorker();
if(!xml)
return 1;
BeginDoc(xml, L"map");
XML_NODE_HANDLE root = GetRootNode(xml);
if(!root)
return 1;
XML_NODE_HANDLE node;
int w, h;
D3DXVECTOR3 pos;
//dimensions
node = AddNode(xml, root, L"dimensions");
if(!node)
return 1;
w = map.GetWidth();
h = map.GetHeight();
os << w;
SetNodeAttr(xml, node, L"width", os.str().c_str());
os.str(L"");
os << h;
SetNodeAttr(xml, node, L"height", os.str().c_str());
os.str(L"");
ReleaseNode(node);
//background
SaveBackground(*map.GetBackground(), xml, root);
//player
SavePlayer( map.GetPlayer(), xml, root );
//tiles
SaveTileList(map.m_pTiles, xml, root);
//creatures
SaveCreatureList(map.m_pCreatures, xml, root);
SaveToFileHandle(xml, hFile, true);
CloseHandle(hFile);
ReleaseWorker(xml);
return 0;
}
/*!
* \brief Determines whether or not a thread should be added based on the
* jobsPerThread ratio. Adds a thread if appropriate.
*
* \remark The ThreadPool object mutex must be locked prior to calling this
* function.
*
* \internal
*/
static void AddWorker(
/*! A pointer to the ThreadPool object. */
ThreadPool *tp)
{
long jobs = 0;
int threads = 0;
jobs = tp->highJobQ.size + tp->lowJobQ.size + tp->medJobQ.size;
threads = tp->totalThreads - tp->persistentThreads;
while (threads == 0 ||
(jobs / threads) >= tp->attr.jobsPerThread ||
(tp->totalThreads == tp->busyThreads) ) {
if (CreateWorker(tp) != 0) {
return;
}
threads++;
}
}
ECommandResult::Type FSubversionSourceControlProvider::Execute( const TSharedRef<ISourceControlOperation, ESPMode::ThreadSafe>& InOperation, const TArray<FString>& InFiles, EConcurrency::Type InConcurrency, const FSourceControlOperationComplete& InOperationCompleteDelegate )
{
if(!IsEnabled())
{
return ECommandResult::Failed;
}
if(!SubversionSourceControlUtils::CheckFilenames(InFiles))
{
return ECommandResult::Failed;
}
TArray<FString> AbsoluteFiles = SourceControlHelpers::AbsoluteFilenames(InFiles);
// Query to see if the we allow this operation
TSharedPtr<ISubversionSourceControlWorker, ESPMode::ThreadSafe> Worker = CreateWorker(InOperation->GetName());
if(!Worker.IsValid())
{
// this operation is unsupported by this source control provider
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("OperationName"), FText::FromName(InOperation->GetName()) );
Arguments.Add( TEXT("ProviderName"), FText::FromName(GetName()) );
FMessageLog("SourceControl").Error(FText::Format(LOCTEXT("UnsupportedOperation", "Operation '{OperationName}' not supported by source control provider '{ProviderName}'"), Arguments));
return ECommandResult::Failed;
}
// fire off operation
if(InConcurrency == EConcurrency::Synchronous)
{
FSubversionSourceControlCommand* Command = new FSubversionSourceControlCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = false;
Command->Files = AbsoluteFiles;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return ExecuteSynchronousCommand(*Command, InOperation->GetInProgressString(), true);
}
else
{
FSubversionSourceControlCommand* Command = new FSubversionSourceControlCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = true;
Command->Files = AbsoluteFiles;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return IssueCommand(*Command, false);
}
}
int ThreadPoolSetAttr(ThreadPool *tp, ThreadPoolAttr *attr)
{
int retCode = 0;
ThreadPoolAttr temp;
int i = 0;
if (!tp)
return EINVAL;
ithread_mutex_lock(&tp->mutex);
if (attr)
temp = *attr;
else
TPAttrInit(&temp);
if (SetPolicyType(temp.schedPolicy) != 0) {
ithread_mutex_unlock(&tp->mutex);
return INVALID_POLICY;
}
tp->attr = temp;
/* add threads */
if (tp->totalThreads < tp->attr.minThreads) {
for (i = tp->totalThreads; i < tp->attr.minThreads; i++) {
retCode = CreateWorker(tp);
if (retCode != 0) {
break;
}
}
}
/* signal changes */
ithread_cond_signal(&tp->condition);
ithread_mutex_unlock(&tp->mutex);
if (retCode != 0)
/* clean up if the min threads could not be created */
ThreadPoolShutdown(tp);
return retCode;
}
int CMapFileIO::LoadTileTypesDict(CTileTypesDict& Dict) const
{
WCHAR* fname = new WCHAR[MAX_PATH];
wsprintf(fname, L"%s\\tiles\\*", g_ContentPath);
WIN32_FIND_DATA ffd;
XML_MANAGER_HANDLE xml = 0;
HANDLE file = INVALID_HANDLE_VALUE;
WCHAR* listpath = new WCHAR[MAX_PATH];
WCHAR* imgpath = new WCHAR[MAX_PATH];
CTileType *t;
HANDLE search = FindFirstFile(fname, &ffd);
do
{
if((ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && ffd.cFileName[0] != '.')
{
wsprintf(listpath, L"%s\\tiles\\%s\\tiles.xml", g_ContentPath, ffd.cFileName);
file = INVALID_HANDLE_VALUE;
file = CreateFile(listpath, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if(file == INVALID_HANDLE_VALUE)
return 1;
xml = 0;
xml = CreateWorker();
if(!xml)
return 1;
DWORD res = ReadFromFileHandle(xml, file);
if(res != ERROR_SUCCESS)
return 1;
CloseHandle(file);
XML_NODE_HANDLE node = RetrieveNode(xml, 0, L"tile");
while(node)
{
//name
LPWSTR name = GetNodeAttr(xml, node, L"name");
XML_NODE_HANDLE hImg = RetrieveNode(xml, node, L"img");
XML_NODE_HANDLE hSt = RetrieveNode(xml, node, L"stats");
XML_NODE_HANDLE hMov = RetrieveNode(xml, node, L"movement");
//img
LPWSTR img = GetNodeAttr(xml, hImg, L"path");
//hp
LPWSTR hpt = GetNodeAttr(xml, hSt, L"hp");
int hp = _wtoi(hpt);
//hrd
LPWSTR hrdt = GetNodeAttr(xml, hSt, L"hardness");
int hrd = _wtoi(hrdt);
LPWSTR rgnt = GetNodeAttr(xml, hSt, L"regenspeed");
float regenval = (float)_wtof(rgnt);
LPWSTR blok = GetNodeAttr(xml, hMov, L"blocks");
bool block = _wcsicmp(blok, L"YES") == 0;
t = Dict.Give(name);
t->SetHardness(hrd);
t->SetMaxHP(hp);
t->SetRegen(regenval);
wsprintf(imgpath, L"tiles\\%s\\%s", ffd.cFileName, img);
t->SetImageFile(imgpath);
t->SetType(ffd.cFileName);
ReleaseNode(hImg);
ReleaseNode(hSt);
ReleaseNode(hMov);
ReleaseTextString(name);
ReleaseTextString(img);
ReleaseTextString(hrdt);
ReleaseTextString(hpt);
ReleaseTextString(blok);
node = GetNextNode(xml, node);
}
}
}while(FindNextFile(search, &ffd) != 0);
ReleaseWorker(xml);
FindClose(search);
delete[] imgpath;
delete[] fname;
delete[] listpath;
return 0;
}
static void PR_CALLBACK Server(void *arg)
{
PRStatus rv;
PRNetAddr serverAddress;
PRThread *me = PR_GetCurrentThread();
CSServer_t *server = (CSServer_t*)arg;
PRSocketOptionData sockOpt;
server->listener = PR_Socket(domain, SOCK_STREAM, protocol);
sockOpt.option = PR_SockOpt_Reuseaddr;
sockOpt.value.reuse_addr = PR_TRUE;
rv = PR_SetSocketOption(server->listener, &sockOpt);
TEST_ASSERT(PR_SUCCESS == rv);
memset(&serverAddress, 0, sizeof(serverAddress));
if (PR_AF_INET6 != domain)
rv = PR_InitializeNetAddr(PR_IpAddrAny, DEFAULT_PORT, &serverAddress);
else
rv = PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET6, DEFAULT_PORT,
&serverAddress);
rv = PR_Bind(server->listener, &serverAddress);
TEST_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(server->listener, server->backlog);
TEST_ASSERT(PR_SUCCESS == rv);
server->started = PR_IntervalNow();
TimeOfDayMessage("Server started at", me);
PR_Lock(server->ml);
server->state = cs_run;
PR_NotifyCondVar(server->stateChange);
PR_Unlock(server->ml);
/*
** Create the first worker (actually, a thread that accepts
** connections and then processes the work load as needed).
** From this point on, additional worker threads are created
** as they are needed by existing worker threads.
*/
rv = CreateWorker(server, &server->pool);
TEST_ASSERT(PR_SUCCESS == rv);
/*
** From here on this thread is merely hanging around as the contact
** point for the main test driver. It's just waiting for the driver
** to declare the test complete.
*/
TEST_LOG(
cltsrv_log_file, TEST_LOG_VERBOSE,
("\tServer(0x%p): waiting for state change\n", me));
PR_Lock(server->ml);
while ((cs_run == server->state) && !Aborted(rv))
{
rv = PR_WaitCondVar(server->stateChange, PR_INTERVAL_NO_TIMEOUT);
}
PR_Unlock(server->ml);
PR_ClearInterrupt();
TEST_LOG(
cltsrv_log_file, TEST_LOG_INFO,
("\tServer(0x%p): shutting down workers\n", me));
/*
** Get all the worker threads to exit. They know how to
** clean up after themselves, so this is just a matter of
** waiting for clorine in the pool to take effect. During
** this stage we're ignoring interrupts.
*/
server->workers.minimum = server->workers.maximum = 0;
PR_Lock(server->ml);
while (!PR_CLIST_IS_EMPTY(&server->list))
{
PRCList *head = PR_LIST_HEAD(&server->list);
CSWorker_t *worker = (CSWorker_t*)head;
TEST_LOG(
cltsrv_log_file, TEST_LOG_VERBOSE,
("\tServer(0x%p): interrupting worker(0x%p)\n", me, worker));
rv = PR_Interrupt(worker->thread);
TEST_ASSERT(PR_SUCCESS == rv);
PR_REMOVE_AND_INIT_LINK(head);
}
while (server->pool.workers > 0)
{
TEST_LOG(
cltsrv_log_file, TEST_LOG_NOTICE,
("\tServer(0x%p): waiting for %u workers to exit\n",
me, server->pool.workers));
(void)PR_WaitCondVar(server->pool.exiting, PR_INTERVAL_NO_TIMEOUT);
}
server->state = cs_exit;
PR_NotifyCondVar(server->stateChange);
PR_Unlock(server->ml);
TEST_LOG(
cltsrv_log_file, TEST_LOG_ALWAYS,
("\tServer(0x%p): stopped after %u operations and %u bytes\n",
me, server->operations, server->bytesTransferred));
if (NULL != server->listener) PR_Close(server->listener);
server->stopped = PR_IntervalNow();
} /* Server */
static void PR_CALLBACK Worker(void *arg)
{
PRStatus rv;
PRNetAddr from;
PRFileDesc *fd = NULL;
PRThread *me = PR_GetCurrentThread();
CSWorker_t *worker = (CSWorker_t*)arg;
CSServer_t *server = worker->server;
CSPool_t *pool = &server->pool;
TEST_LOG(
cltsrv_log_file, TEST_LOG_NOTICE,
("\t\tWorker(0x%p): started [%u]\n", me, pool->workers + 1));
PR_Lock(server->ml);
PR_APPEND_LINK(&worker->element, &server->list);
pool->workers += 1; /* define our existance */
while (cs_run == server->state)
{
while (pool->accepting >= server->workers.accepting)
{
TEST_LOG(
cltsrv_log_file, TEST_LOG_VERBOSE,
("\t\tWorker(0x%p): waiting for accept slot[%d]\n",
me, pool->accepting));
rv = PR_WaitCondVar(pool->acceptComplete, PR_INTERVAL_NO_TIMEOUT);
if (Aborted(rv) || (cs_run != server->state))
{
TEST_LOG(
cltsrv_log_file, TEST_LOG_NOTICE,
("\tWorker(0x%p): has been %s\n",
me, (Aborted(rv) ? "interrupted" : "stopped")));
goto exit;
}
}
pool->accepting += 1; /* how many are really in accept */
PR_Unlock(server->ml);
TEST_LOG(
cltsrv_log_file, TEST_LOG_VERBOSE,
("\t\tWorker(0x%p): calling accept\n", me));
fd = PR_Accept(server->listener, &from, PR_INTERVAL_NO_TIMEOUT);
PR_Lock(server->ml);
pool->accepting -= 1;
PR_NotifyCondVar(pool->acceptComplete);
if ((NULL == fd) && Aborted(PR_FAILURE))
{
if (NULL != server->listener)
{
PR_Close(server->listener);
server->listener = NULL;
}
goto exit;
}
if (NULL != fd)
{
/*
** Create another worker of the total number of workers is
** less than the minimum specified or we have none left in
** accept() AND we're not over the maximum.
** This sort of presumes that the number allowed in accept
** is at least as many as the minimum. Otherwise we'll keep
** creating new threads and deleting them soon after.
*/
PRBool another =
((pool->workers < server->workers.minimum) ||
((0 == pool->accepting)
&& (pool->workers < server->workers.maximum))) ?
PR_TRUE : PR_FALSE;
pool->active += 1;
PR_Unlock(server->ml);
if (another) (void)CreateWorker(server, pool);
rv = ProcessRequest(fd, server);
if (PR_SUCCESS != rv)
TEST_LOG(
cltsrv_log_file, TEST_LOG_ERROR,
("\t\tWorker(0x%p): server process ended abnormally\n", me));
(void)PR_Close(fd); fd = NULL;
PR_Lock(server->ml);
pool->active -= 1;
}
}
exit:
PR_ClearInterrupt();
PR_Unlock(server->ml);
if (NULL != fd)
{
(void)PR_Shutdown(fd, PR_SHUTDOWN_BOTH);
(void)PR_Close(fd);
}
TEST_LOG(
cltsrv_log_file, TEST_LOG_NOTICE,
("\t\tWorker(0x%p): exiting [%u]\n", PR_GetCurrentThread(), pool->workers));
PR_Lock(server->ml);
pool->workers -= 1; /* undefine our existance */
PR_REMOVE_AND_INIT_LINK(&worker->element);
PR_NotifyCondVar(pool->exiting);
PR_Unlock(server->ml);
PR_DELETE(worker); /* destruction of the "worker" object */
} /* Worker */
ECommandResult::Type FProvider::Execute(
const TSharedRef<ISourceControlOperation, ESPMode::ThreadSafe>& InOperation,
const TArray<FString>& InFiles,
EConcurrency::Type InConcurrency,
const FSourceControlOperationComplete& InOperationCompleteDelegate
)
{
// the "Connect" operation is the only operation that can be performed while the
// provider is disabled, if the operation is successful the provider will be enabled
if (!IsEnabled() && (InOperation->GetName() != OperationNames::Connect))
{
return ECommandResult::Failed;
}
// attempt to create a worker to perform the requested operation
FWorkerPtr WorkerPtr = CreateWorker(InOperation->GetName());
if (!WorkerPtr.IsValid())
{
// apparently we don't support this particular operation
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OperationName"), FText::FromName(InOperation->GetName()));
Arguments.Add(TEXT("ProviderName"), FText::FromName(GetName()));
LogError(
FText::Format(
LOCTEXT(
"UnsupportedOperation",
"Operation '{OperationName}' not supported by source control provider '{ProviderName}'"
),
Arguments
)
);
return ECommandResult::Failed;
}
auto* Command = new FCommand(
GetWorkingDirectory(), AbsoluteContentDirectory, InOperation,
WorkerPtr.ToSharedRef(), InOperationCompleteDelegate
);
TArray<FString> AbsoluteFiles;
if (InOperation->GetName() == OperationNames::Connect)
{
AbsoluteFiles.Add(Settings.GetMercurialPath());
}
else if (InOperation->GetName() == OperationNames::MarkForAdd)
{
TArray<FString> AbsoluteLargeFiles;
PrepareFilenamesForAddCommand(InFiles, AbsoluteFiles, AbsoluteLargeFiles);
if (AbsoluteLargeFiles.Num() > 0)
{
Command->SetAbsoluteLargeFiles(AbsoluteLargeFiles);
}
}
else
{
for (const auto& Filename : InFiles)
{
AbsoluteFiles.Add(FPaths::ConvertRelativePathToFull(Filename));
}
}
if (AbsoluteFiles.Num() > 0)
{
Command->SetAbsoluteFiles(AbsoluteFiles);
}
if (InConcurrency == EConcurrency::Synchronous)
{
auto Result = ExecuteSynchronousCommand(Command, InOperation->GetInProgressString());
delete Command;
return Result;
}
else
{
return ExecuteCommand(Command, true);
}
}
int ThreadPoolInit(ThreadPool *tp, ThreadPoolAttr *attr)
{
int retCode = 0;
int i = 0;
if (!tp) {
return EINVAL;
}
retCode += ithread_mutex_init(&tp->mutex, NULL);
retCode += ithread_mutex_lock(&tp->mutex);
retCode += ithread_cond_init(&tp->condition, NULL);
retCode += ithread_cond_init(&tp->start_and_shutdown, NULL);
if (retCode) {
ithread_mutex_unlock(&tp->mutex);
ithread_mutex_destroy(&tp->mutex);
ithread_cond_destroy(&tp->condition);
ithread_cond_destroy(&tp->start_and_shutdown);
return EAGAIN;
}
if (attr) {
tp->attr = *attr;
} else {
TPAttrInit(&tp->attr);
}
if (SetPolicyType(tp->attr.schedPolicy) != 0) {
ithread_mutex_unlock(&tp->mutex);
ithread_mutex_destroy(&tp->mutex);
ithread_cond_destroy(&tp->condition);
ithread_cond_destroy(&tp->start_and_shutdown);
return INVALID_POLICY;
}
retCode += FreeListInit(
&tp->jobFreeList, sizeof(ThreadPoolJob), JOBFREELISTSIZE);
StatsInit(&tp->stats);
retCode += ListInit(&tp->highJobQ, CmpThreadPoolJob, NULL);
retCode += ListInit(&tp->medJobQ, CmpThreadPoolJob, NULL);
retCode += ListInit(&tp->lowJobQ, CmpThreadPoolJob, NULL);
if (retCode) {
retCode = EAGAIN;
} else {
tp->persistentJob = NULL;
tp->lastJobId = 0;
tp->shutdown = 0;
tp->totalThreads = 0;
tp->busyThreads = 0;
tp->persistentThreads = 0;
tp->pendingWorkerThreadStart = 0;
for (i = 0; i < tp->attr.minThreads; ++i) {
retCode = CreateWorker(tp);
if (retCode) {
break;
}
}
}
ithread_mutex_unlock(&tp->mutex);
if (retCode) {
/* clean up if the min threads could not be created */
ThreadPoolShutdown(tp);
}
return retCode;
}
/****************************************************************************
* Function: ThreadPoolInit
*
* Description:
* Initializes and starts ThreadPool. Must be called first.
* And only once for ThreadPool.
* Parameters:
* tp - must be valid, non null, pointer to ThreadPool.
* minWorkerThreads - minimum number of worker threads
* thread pool will never have less than this
* number of threads.
* maxWorkerThreads - maximum number of worker threads
* thread pool will never have more than this
* number of threads.
* maxIdleTime - maximum time that a worker thread will spend
* idle. If a worker is idle longer than this
* time and there are more than the min
* number of workers running, than the
* worker thread exits.
* jobsPerThread - ratio of jobs to thread to try and maintain
* if a job is scheduled and the number of jobs per
* thread is greater than this number,and
* if less than the maximum number of
* workers are running then a new thread is
* started to help out with efficiency.
* schedPolicy - scheduling policy to try and set (OS dependent)
* Returns:
* 0 on success, nonzero on failure.
* EAGAIN if not enough system resources to create minimum threads.
* INVALID_POLICY if schedPolicy can't be set
* EMAXTHREADS if minimum threads is greater than maximum threads
*****************************************************************************/
int ThreadPoolInit( ThreadPool *tp, ThreadPoolAttr *attr )
{
int retCode = 0;
int i = 0;
//printf("%s, %d\n", __FUNCTION__, __LINE__);
assert( tp != NULL );
if( tp == NULL ) {
return EINVAL;
}
#ifdef WIN32
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
#endif
#endif
//printf("%s, %d\n", __FUNCTION__, __LINE__);
retCode += ithread_mutex_init( &tp->mutex, NULL );
assert( retCode == 0 );
retCode += ithread_mutex_lock( &tp->mutex );
assert( retCode == 0 );
retCode += ithread_cond_init( &tp->condition, NULL );
assert( retCode == 0 );
retCode += ithread_cond_init( &tp->start_and_shutdown, NULL );
assert( retCode == 0 );
//printf("%s, %d\n", __FUNCTION__, __LINE__);
if( retCode != 0 ) {
return EAGAIN;
}
if( attr ) {
tp->attr = ( *attr );
} else {
TPAttrInit( &tp->attr );
}
//printf("%s, %d, minthreads: %d\n", __FUNCTION__, __LINE__, tp->attr.minThreads);
if( SetPolicyType( tp->attr.schedPolicy ) != 0 ) {
ithread_mutex_unlock( &tp->mutex );
ithread_mutex_destroy( &tp->mutex );
ithread_cond_destroy( &tp->condition );
ithread_cond_destroy( &tp->start_and_shutdown );
return INVALID_POLICY;
}
//printf("%s, %d\n", __FUNCTION__, __LINE__);
retCode += FreeListInit(
&tp->jobFreeList, sizeof( ThreadPoolJob ), JOBFREELISTSIZE );
assert( retCode == 0 );
StatsInit( &tp->stats );
retCode += ListInit( &tp->highJobQ, CmpThreadPoolJob, NULL );
assert( retCode == 0 );
retCode += ListInit( &tp->medJobQ, CmpThreadPoolJob, NULL );
assert( retCode == 0 );
retCode += ListInit( &tp->lowJobQ, CmpThreadPoolJob, NULL );
assert( retCode == 0 );
//printf("%s, %d, retcode is %d\n", __FUNCTION__, __LINE__, retCode);
if( retCode != 0 ) {
retCode = EAGAIN;
//printf("%s, %d\n", __FUNCTION__, __LINE__);
} else {
//printf("%s, %d\n", __FUNCTION__, __LINE__);
tp->persistentJob = NULL;
tp->lastJobId = 0;
tp->shutdown = 0;
tp->totalThreads = 0;
tp->persistentThreads = 0;
//printf("%s, %d\n", __FUNCTION__, __LINE__);
for( i = 0; i < tp->attr.minThreads; ++i ) {
if( ( retCode = CreateWorker( tp ) ) != 0 ) {
//printf("%s, %d\n", __FUNCTION__, __LINE__);
break;
}
}
}
//printf("%s, %d\n", __FUNCTION__, __LINE__);
ithread_mutex_unlock( &tp->mutex );
if( retCode != 0 ) {
// clean up if the min threads could not be created
ThreadPoolShutdown( tp );
}
//printf("%s, %d\n", __FUNCTION__, __LINE__);
return retCode;
}
int CMapFileIO::LoadMap(CLevelMap &map, HANDLE hFile) const
{
XML_MANAGER_HANDLE xml = 0;
xml = CreateWorker();
if(!xml)
return 1;
DWORD res = ReadFromFileHandle(xml, hFile);
if(res != ERROR_SUCCESS)
return 1;
CloseHandle(hFile);
XML_NODE_HANDLE group;
//dimensions
group = RetrieveNode(xml, 0, L"dimensions");
if(!group)
return 1;
LPWSTR mapwt = GetNodeAttr(xml, group, L"width");
if(!mapwt)
return 1;
LPWSTR mapht = GetNodeAttr(xml, group, L"height");
if(!mapht)
return 1;
int mapw = _wtoi(mapwt);
int maph = _wtoi(mapht);
map.SetDimensions(mapw, maph);
ReleaseTextString(mapwt);
ReleaseTextString(mapht);
ReleaseNode(group);
//background
group = RetrieveNode(xml, 0, L"background");
if(!group)
return 1;
map.SetBackground(LoadBackground(xml, group));
ReleaseNode(group);
//player
group = RetrieveNode(xml, 0, L"player");
CStubCreature* pPlr = 0;
if(group)
{
pPlr = LoadPlayer(xml, group);
map.SetPlayerPos(pPlr->GetPosition());
delete pPlr;
}
ReleaseNode(group);
//tiletypes
LoadTileTypesDict(map.m_TilesDictionary);
//tiles
group = RetrieveNode(xml, 0, L"tiles");
if(!group)
return 1;
LoadTileList(map.m_pTiles, map.m_TilesDictionary, xml, group);
ReleaseNode(group);
//creatures
group = RetrieveNode(xml, 0, L"creatures");
if(group)
LoadCreaturesList( map.m_pCreatures, xml, group );
ReleaseNode(group);
map.AssignMyEnviroment();
ReleaseWorker(xml);
return 0;
}
