Download 3rdparty/libwebp/src/utils/thread_utils.c from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 11.2 kB
-
https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/thread_utils.c
- Command line
-
hf download hf://tgollogly/test/3rdparty/libwebp/src/utils/thread_utils.c
-
curl -L -o thread_utils.c https://huggingface.co/tgollogly/test/resolve/main/3rdparty/libwebp/src/utils/thread_utils.c
11.2 kB
| // Copyright 2011 Google Inc. All Rights Reserved. | |
| // | |
| // Use of this source code is governed by a BSD-style license | |
| // that can be found in the COPYING file in the root of the source | |
| // tree. An additional intellectual property rights grant can be found | |
| // in the file PATENTS. All contributing project authors may | |
| // be found in the AUTHORS file in the root of the source tree. | |
| // ----------------------------------------------------------------------------- | |
| // | |
| // Multi-threaded worker | |
| // | |
| // Author: Skal (pascal.massimino@gmail.com) | |
| typedef HANDLE pthread_t; | |
| typedef CRITICAL_SECTION pthread_mutex_t; | |
| typedef CONDITION_VARIABLE pthread_cond_t; | |
| typedef struct { | |
| HANDLE waiting_sem_; | |
| HANDLE received_sem_; | |
| HANDLE signal_event_; | |
| } pthread_cond_t; | |
| typedef struct { | |
| pthread_mutex_t mutex_; | |
| pthread_cond_t condition_; | |
| pthread_t thread_; | |
| } WebPWorkerImpl; | |
| //------------------------------------------------------------------------------ | |
| // simplistic pthread emulation layer | |
| // _beginthreadex requires __stdcall | |
| static int pthread_create(pthread_t* const thread, const void* attr, | |
| unsigned int (__stdcall* start)(void*), void* arg) { | |
| (void)attr; | |
| *thread = CreateThread(NULL, /* lpThreadAttributes */ | |
| 0, /* dwStackSize */ | |
| start, | |
| arg, | |
| 0, /* dwStackSize */ | |
| NULL); /* lpThreadId */ | |
| *thread = (pthread_t)_beginthreadex(NULL, /* void *security */ | |
| 0, /* unsigned stack_size */ | |
| start, | |
| arg, | |
| 0, /* unsigned initflag */ | |
| NULL); /* unsigned *thrdaddr */ | |
| if (*thread == NULL) return 1; | |
| SetThreadPriority(*thread, THREAD_PRIORITY_ABOVE_NORMAL); | |
| return 0; | |
| } | |
| static int pthread_join(pthread_t thread, void** value_ptr) { | |
| (void)value_ptr; | |
| return (WaitForSingleObject(thread, INFINITE) != WAIT_OBJECT_0 || | |
| CloseHandle(thread) == 0); | |
| } | |
| // Mutex | |
| static int pthread_mutex_init(pthread_mutex_t* const mutex, void* mutexattr) { | |
| (void)mutexattr; | |
| InitializeCriticalSectionEx(mutex, 0 /*dwSpinCount*/, 0 /*Flags*/); | |
| InitializeCriticalSection(mutex); | |
| return 0; | |
| } | |
| static int pthread_mutex_lock(pthread_mutex_t* const mutex) { | |
| EnterCriticalSection(mutex); | |
| return 0; | |
| } | |
| static int pthread_mutex_unlock(pthread_mutex_t* const mutex) { | |
| LeaveCriticalSection(mutex); | |
| return 0; | |
| } | |
| static int pthread_mutex_destroy(pthread_mutex_t* const mutex) { | |
| DeleteCriticalSection(mutex); | |
| return 0; | |
| } | |
| // Condition | |
| static int pthread_cond_destroy(pthread_cond_t* const condition) { | |
| int ok = 1; | |
| (void)condition; | |
| ok &= (CloseHandle(condition->waiting_sem_) != 0); | |
| ok &= (CloseHandle(condition->received_sem_) != 0); | |
| ok &= (CloseHandle(condition->signal_event_) != 0); | |
| return !ok; | |
| } | |
| static int pthread_cond_init(pthread_cond_t* const condition, void* cond_attr) { | |
| (void)cond_attr; | |
| InitializeConditionVariable(condition); | |
| condition->waiting_sem_ = CreateSemaphore(NULL, 0, 1, NULL); | |
| condition->received_sem_ = CreateSemaphore(NULL, 0, 1, NULL); | |
| condition->signal_event_ = CreateEvent(NULL, FALSE, FALSE, NULL); | |
| if (condition->waiting_sem_ == NULL || | |
| condition->received_sem_ == NULL || | |
| condition->signal_event_ == NULL) { | |
| pthread_cond_destroy(condition); | |
| return 1; | |
| } | |
| return 0; | |
| } | |
| static int pthread_cond_signal(pthread_cond_t* const condition) { | |
| int ok = 1; | |
| WakeConditionVariable(condition); | |
| if (WaitForSingleObject(condition->waiting_sem_, 0) == WAIT_OBJECT_0) { | |
| // a thread is waiting in pthread_cond_wait: allow it to be notified | |
| ok = SetEvent(condition->signal_event_); | |
| // wait until the event is consumed so the signaler cannot consume | |
| // the event via its own pthread_cond_wait. | |
| ok &= (WaitForSingleObject(condition->received_sem_, INFINITE) != | |
| WAIT_OBJECT_0); | |
| } | |
| return !ok; | |
| } | |
| static int pthread_cond_wait(pthread_cond_t* const condition, | |
| pthread_mutex_t* const mutex) { | |
| int ok; | |
| ok = SleepConditionVariableCS(condition, mutex, INFINITE); | |
| // note that there is a consumer available so the signal isn't dropped in | |
| // pthread_cond_signal | |
| if (!ReleaseSemaphore(condition->waiting_sem_, 1, NULL)) return 1; | |
| // now unlock the mutex so pthread_cond_signal may be issued | |
| pthread_mutex_unlock(mutex); | |
| ok = (WaitForSingleObject(condition->signal_event_, INFINITE) == | |
| WAIT_OBJECT_0); | |
| ok &= ReleaseSemaphore(condition->received_sem_, 1, NULL); | |
| pthread_mutex_lock(mutex); | |
| return !ok; | |
| } | |
| //------------------------------------------------------------------------------ | |
| static THREADFN ThreadLoop(void* ptr) { | |
| WebPWorker* const worker = (WebPWorker*)ptr; | |
| WebPWorkerImpl* const impl = (WebPWorkerImpl*)worker->impl_; | |
| int done = 0; | |
| while (!done) { | |
| pthread_mutex_lock(&impl->mutex_); | |
| while (worker->status_ == OK) { // wait in idling mode | |
| pthread_cond_wait(&impl->condition_, &impl->mutex_); | |
| } | |
| if (worker->status_ == WORK) { | |
| WebPGetWorkerInterface()->Execute(worker); | |
| worker->status_ = OK; | |
| } else if (worker->status_ == NOT_OK) { // finish the worker | |
| done = 1; | |
| } | |
| // signal to the main thread that we're done (for Sync()) | |
| // Note the associated mutex does not need to be held when signaling the | |
| // condition. Unlocking the mutex first may improve performance in some | |
| // implementations, avoiding the case where the waiting thread can't | |
| // reacquire the mutex when woken. | |
| pthread_mutex_unlock(&impl->mutex_); | |
| pthread_cond_signal(&impl->condition_); | |
| } | |
| return THREAD_RETURN(NULL); // Thread is finished | |
| } | |
| // main thread state control | |
| static void ChangeState(WebPWorker* const worker, WebPWorkerStatus new_status) { | |
| // No-op when attempting to change state on a thread that didn't come up. | |
| // Checking status_ without acquiring the lock first would result in a data | |
| // race. | |
| WebPWorkerImpl* const impl = (WebPWorkerImpl*)worker->impl_; | |
| if (impl == NULL) return; | |
| pthread_mutex_lock(&impl->mutex_); | |
| if (worker->status_ >= OK) { | |
| // wait for the worker to finish | |
| while (worker->status_ != OK) { | |
| pthread_cond_wait(&impl->condition_, &impl->mutex_); | |
| } | |
| // assign new status and release the working thread if needed | |
| if (new_status != OK) { | |
| worker->status_ = new_status; | |
| // Note the associated mutex does not need to be held when signaling the | |
| // condition. Unlocking the mutex first may improve performance in some | |
| // implementations, avoiding the case where the waiting thread can't | |
| // reacquire the mutex when woken. | |
| pthread_mutex_unlock(&impl->mutex_); | |
| pthread_cond_signal(&impl->condition_); | |
| return; | |
| } | |
| } | |
| pthread_mutex_unlock(&impl->mutex_); | |
| } | |
| //------------------------------------------------------------------------------ | |
| static void Init(WebPWorker* const worker) { | |
| memset(worker, 0, sizeof(*worker)); | |
| worker->status_ = NOT_OK; | |
| } | |
| static int Sync(WebPWorker* const worker) { | |
| ChangeState(worker, OK); | |
| assert(worker->status_ <= OK); | |
| return !worker->had_error; | |
| } | |
| static int Reset(WebPWorker* const worker) { | |
| int ok = 1; | |
| worker->had_error = 0; | |
| if (worker->status_ < OK) { | |
| WebPWorkerImpl* const impl = | |
| (WebPWorkerImpl*)WebPSafeCalloc(1, sizeof(WebPWorkerImpl)); | |
| worker->impl_ = (void*)impl; | |
| if (worker->impl_ == NULL) { | |
| return 0; | |
| } | |
| if (pthread_mutex_init(&impl->mutex_, NULL)) { | |
| goto Error; | |
| } | |
| if (pthread_cond_init(&impl->condition_, NULL)) { | |
| pthread_mutex_destroy(&impl->mutex_); | |
| goto Error; | |
| } | |
| pthread_mutex_lock(&impl->mutex_); | |
| ok = !pthread_create(&impl->thread_, NULL, ThreadLoop, worker); | |
| if (ok) worker->status_ = OK; | |
| pthread_mutex_unlock(&impl->mutex_); | |
| if (!ok) { | |
| pthread_mutex_destroy(&impl->mutex_); | |
| pthread_cond_destroy(&impl->condition_); | |
| Error: | |
| WebPSafeFree(impl); | |
| worker->impl_ = NULL; | |
| return 0; | |
| } | |
| worker->status_ = OK; | |
| } else if (worker->status_ > OK) { | |
| ok = Sync(worker); | |
| } | |
| assert(!ok || (worker->status_ == OK)); | |
| return ok; | |
| } | |
| static void Execute(WebPWorker* const worker) { | |
| if (worker->hook != NULL) { | |
| worker->had_error |= !worker->hook(worker->data1, worker->data2); | |
| } | |
| } | |
| static void Launch(WebPWorker* const worker) { | |
| ChangeState(worker, WORK); | |
| Execute(worker); | |
| } | |
| static void End(WebPWorker* const worker) { | |
| if (worker->impl_ != NULL) { | |
| WebPWorkerImpl* const impl = (WebPWorkerImpl*)worker->impl_; | |
| ChangeState(worker, NOT_OK); | |
| pthread_join(impl->thread_, NULL); | |
| pthread_mutex_destroy(&impl->mutex_); | |
| pthread_cond_destroy(&impl->condition_); | |
| WebPSafeFree(impl); | |
| worker->impl_ = NULL; | |
| } | |
| worker->status_ = NOT_OK; | |
| assert(worker->impl_ == NULL); | |
| assert(worker->status_ == NOT_OK); | |
| } | |
| //------------------------------------------------------------------------------ | |
| static WebPWorkerInterface g_worker_interface = { | |
| Init, Reset, Sync, Launch, Execute, End | |
| }; | |
| int WebPSetWorkerInterface(const WebPWorkerInterface* const winterface) { | |
| if (winterface == NULL || | |
| winterface->Init == NULL || winterface->Reset == NULL || | |
| winterface->Sync == NULL || winterface->Launch == NULL || | |
| winterface->Execute == NULL || winterface->End == NULL) { | |
| return 0; | |
| } | |
| g_worker_interface = *winterface; | |
| return 1; | |
| } | |
| const WebPWorkerInterface* WebPGetWorkerInterface(void) { | |
| return &g_worker_interface; | |
| } | |
| //------------------------------------------------------------------------------ | |