openharmony/arkcompiler_ets_runtime
1
0
Fork 0
mirror of https://gitee.com/openharmony/arkcompiler_ets_runtime synced 2024-11-23 01:59:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "pthread_mutex_t adapt to ffrt"

Browse Source 
Issue:https://gitee.com/openharmony/arkcompiler_ets_runtime/issues/IAYFNV

Change-Id: I29190a098555df04c8213973e5dabf5cc72a9327
Signed-off-by: chentianyu <chentianyu31@huawei.com>
This commit is contained in:
chentianyu 2024-10-21 09:28:52 +08:00
parent e4854aff4b
commit 4f9ecf4c31
9 changed files with 5 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD.gn
View File

@ -998,7 +998,7 @@ ecma_platform_source += [
"ecmascript/platform/common/map.cpp",
"ecmascript/platform/common/mutex.cpp",
"ecmascript/platform/common/filesystem.cpp",
"ecmascript/platform/common/ffrt_adapter.cpp",
"ecmascript/platform/common/ffrt.cpp",
]
config("include_llvm") {

2
ecmascript/dfx/cpu_profiler/cpu_profiler.cpp
View File

@ -22,7 +22,7 @@
#include "ecmascript/compiler/aot_file/aot_file_manager.h"
#include "ecmascript/jspandafile/js_pandafile_manager.h"
#include "ecmascript/platform/ffrt_adapter.h"
#include "ecmascript/platform/ffrt.h"
#if defined(ENABLE_FFRT_INTERFACES)
#include "c/executor_task.h"

20
ecmascript/js_thread.cpp
View File

@ -753,11 +753,7 @@ void JSThread::CheckAndPassActiveBarrier()
bool JSThread::PassSuspendBarrier()
{
// Use suspendLock_ to avoid data-race between suspend-all-thread and suspended-threads.
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder hock(suspendLock_);
#else
LockHolder lock(suspendLock_);
#endif
if (suspendBarrier_ != nullptr) {
suspendBarrier_->PassStrongly();
suspendBarrier_ = nullptr;
@ -1156,11 +1152,7 @@ void JSThread::UpdateState(ThreadState newState)
void JSThread::SuspendThread(bool internalSuspend, SuspendBarrier* barrier)
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder hock(suspendLock_);
#else
LockHolder lock(suspendLock_);
#endif
if (!internalSuspend) {
// do smth here if we want to combine internal and external suspension
}
@ -1181,11 +1173,7 @@ void JSThread::SuspendThread(bool internalSuspend, SuspendBarrier* barrier)
void JSThread::ResumeThread(bool internalSuspend)
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder hock(suspendLock_);
#else
LockHolder lock(suspendLock_);
#endif
if (!internalSuspend) {
// do smth here if we want to combine internal and external suspension
}
@ -1206,11 +1194,7 @@ void JSThread::WaitSuspension()
UpdateState(ThreadState::IS_SUSPENDED);
{
ECMA_BYTRACE_NAME(HITRACE_TAG_ARK, "SuspendTime::WaitSuspension");
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(suspendLock_);
#else
LockHolder lock(suspendLock_);
#endif
while (suspendCount_ > 0) {
suspendCondVar_.TimedWait(&suspendLock_, TIMEOUT);
// we need to do smth if Runtime is terminating at this point
@ -1302,11 +1286,7 @@ void JSThread::StoreRunningState(ThreadState newState)
} else if ((oldStateAndFlags.asNonvolatileStruct.flags & ThreadFlag::SUSPEND_REQUEST) != 0) {
constexpr int TIMEOUT = 100;
ECMA_BYTRACE_NAME(HITRACE_TAG_ARK, "SuspendTime::StoreRunningState");
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(suspendLock_);
#else
LockHolder lock(suspendLock_);
#endif
while (suspendCount_ > 0) {
suspendCondVar_.TimedWait(&suspendLock_, TIMEOUT);
}

10
ecmascript/js_thread.h
View File

@ -21,7 +21,7 @@
#include <string>
#include <cstdint>
#include "ecmascript/platform/ffrt_adapter.h"
#include "ecmascript/platform/ffrt.h"
#include "ecmascript/base/aligned_struct.h"
#include "ecmascript/builtin_entries.h"
#include "ecmascript/daemon/daemon_task.h"
@ -37,7 +37,6 @@
#if defined(ENABLE_FFRT_INTERFACES)
#include "ffrt.h"
#include "c/executor_task.h"
#include "ecmascript/platform/ffrt_mutex.h"
#endif
namespace panda::ecmascript {
@ -1610,14 +1609,9 @@ private:
CVector<EcmaContext *> contexts_;
EcmaContext *currentContext_ {nullptr};
#if defined(ENABLE_FFRT_INTERFACES)
FFRTMutex suspendLock_;
FFRTConditionVariable suspendCondVar_;
#else
Mutex suspendLock_;
ConditionVariable suspendCondVar_;
#endif
int32_t suspendCount_ {0};
ConditionVariable suspendCondVar_;
SuspendBarrier *suspendBarrier_ {nullptr};
uint64_t jobId_ {0};

2
ecmascript/platform/common/ffrt_adapter.cpp → ecmascript/platform/common/ffrt.cpp
View File

@ -13,7 +13,7 @@
* limitations under the License.
*/
#include "ecmascript/platform/ffrt_adapter.h"
#include "ecmascript/platform/ffrt.h"
#include "libpandabase/os/thread.h"
#if defined(ENABLE_FFRT_INTERFACES)

0
ecmascript/platform/ffrt_adapter.h → ecmascript/platform/ffrt.h
View File

176
ecmascript/platform/ffrt_mutex.h
View File

@ -1,176 +0,0 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ECMASCRIPT_PLATFORM_FFRT_MUTEX_H
#define ECMASCRIPT_PLATFORM_FFRT_MUTEX_H
#include "ffrt.h"
#include "ecmascript/common.h"
#ifdef DEBUG
#define FATAL_IF_ERROR(f, rc) \
do { \
if (rc != 0) { \
LOG_ECMA(FATAL)<< f << " failed: " << rc; \
} \
} while (false)
#else
#define FATAL_IF_ERROR(f, rc) static_cast<void>(0)
#endif
namespace panda::ecmascript {
class PUBLIC_API FFRTMutex {
public:
explicit FFRTMutex(bool is_init = true)
{
if (is_init) {
Init(nullptr);
}
}
~FFRTMutex()
{
[[maybe_unused]]int rc = ffrt_mutex_destroy(&mutex_);
FATAL_IF_ERROR("ffrt_mutex_destroy", rc);
}
void Lock()
{
[[maybe_unused]]int rc = ffrt_mutex_lock(&mutex_);
FATAL_IF_ERROR("ffrt_mutex_lock", rc);
}
bool TryLock()
{
int rc = ffrt_mutex_trylock(&mutex_);
if (rc == EBUSY) {
return false;
}
FATAL_IF_ERROR("ffrt_mutex_trylock", rc);
return true;
}
void Unlock()
{
[[maybe_unused]]int rc = ffrt_mutex_unlock(&mutex_);
FATAL_IF_ERROR("ffrt_mutex_unlock", rc);
}
protected:
void Init(ffrt_mutexattr_t *attrs)
{
[[maybe_unused]]int rc = ffrt_mutex_init(&mutex_, attrs);
FATAL_IF_ERROR("ffrt_mutex_init", rc);
}
private:
ffrt_mutex_t mutex_;
friend class FFRTConditionVariable;
};
class PUBLIC_API FFRTConditionVariable {
public:
FFRTConditionVariable()
{
[[maybe_unused]]int rc = ffrt_cond_init(&cond_, nullptr);
FATAL_IF_ERROR("ffrt_cond_init", rc);
}
~FFRTConditionVariable()
{
[[maybe_unused]]int rc = ffrt_cond_destroy(&cond_);
FATAL_IF_ERROR("ffrt_cond_destroy", rc);
}
void Signal()
{
[[maybe_unused]]int rc = ffrt_cond_signal(&cond_);
FATAL_IF_ERROR("ffrt_cond_signal", rc);
}
void SignalAll()
{
[[maybe_unused]]int rc = ffrt_cond_broadcast(&cond_);
FATAL_IF_ERROR("ffrt_cond_broadcast", rc);
}
void Wait(FFRTMutex *mutex)
{
[[maybe_unused]]int rc = ffrt_cond_wait(&cond_, &mutex->mutex_);
FATAL_IF_ERROR("ffrt_cond_wait", rc);
}
bool TimedWait(FFRTMutex *mutex, uint64_t ms, uint64_t ns = 0, bool is_absolute = false)
{
struct timespec abs_time = ConvertTime(ms, ns, is_absolute);
int rc = ffrt_cond_timedwait(&cond_, &mutex->mutex_, &abs_time);
if (rc != 0) {
if (rc == ETIMEDOUT) {
// interrupted
return true;
}
}
FATAL_IF_ERROR("ffrt_cond_timedwait", rc);
return false;
}
protected:
struct timespec ConvertTime(uint64_t ms, uint64_t ns, bool is_absolute)
{
struct timespec abs_time = {0, 0};
if (!is_absolute) {
clock_gettime(CLOCK_REALTIME, &abs_time);
}
const int64_t MILLISECONDS_PER_SEC = 1000;
const int64_t NANOSECONDS_PER_MILLISEC = 1000000;
const int64_t NANOSECONDS_PER_SEC = 1000000000;
time_t seconds = ms / MILLISECONDS_PER_SEC;
time_t nanoseconds = (ms % MILLISECONDS_PER_SEC) * NANOSECONDS_PER_MILLISEC + ns;
abs_time.tv_sec += seconds;
abs_time.tv_nsec += nanoseconds;
if (abs_time.tv_nsec >= NANOSECONDS_PER_SEC) {
abs_time.tv_nsec -= NANOSECONDS_PER_SEC;
abs_time.tv_sec++;
}
return abs_time;
}
private:
ffrt_cond_t cond_;
};
class FFRTLockHolder {
public:
explicit FFRTLockHolder(FFRTMutex &mtx) : lock_(mtx)
{
lock_.Lock();
}
~FFRTLockHolder()
{
lock_.Unlock();
}
private:
FFRTMutex &lock_;
NO_COPY_SEMANTIC(FFRTLockHolder);
NO_MOVE_SEMANTIC(FFRTLockHolder);
};
} // namespace panda::ecmascript
#endif // ECMASCRIPT_PLATFORM_FFRT_MUTEX_H

20
ecmascript/runtime.cpp
View File

@ -134,11 +134,7 @@ void Runtime::DestroyIfLastVm()
void Runtime::RegisterThread(JSThread* newThread)
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(threadsLock_);
#else
LockHolder lock(threadsLock_);
#endif
ASSERT(std::find(threads_.begin(), threads_.end(), newThread) == threads_.end());
threads_.emplace_back(newThread);
// send all current suspended requests to the new thread
@ -150,11 +146,7 @@ void Runtime::RegisterThread(JSThread* newThread)
// Note: currently only called when thread is to be destroyed.
void Runtime::UnregisterThread(JSThread* thread)
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(threadsLock_);
#else
LockHolder lock(threadsLock_);
#endif
ASSERT(std::find(threads_.begin(), threads_.end(), thread) != threads_.end());
ASSERT(!thread->IsInRunningState());
threads_.remove(thread);
@ -187,11 +179,7 @@ void Runtime::SuspendAllThreadsImpl(JSThread *current)
SuspendBarrier barrier;
for (uint32_t iterCount = 1U;; ++iterCount) {
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(threadsLock_);
#else
LockHolder lock(threadsLock_);
#endif
if (suspendNewCount_ == 0) {
suspendNewCount_++;
if (threads_.size() == 1) {
@ -230,11 +218,7 @@ void Runtime::SuspendAllThreadsImpl(JSThread *current)
}
}
if (iterCount < MAX_SUSPEND_RETRIES) {
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(threadsLock_);
#else
LockHolder lock(threadsLock_);
#endif
if (suspendNewCount_ != 0) {
// Someone has already suspended all threads.
// Wait until it finishes.
@ -250,11 +234,7 @@ void Runtime::SuspendAllThreadsImpl(JSThread *current)
void Runtime::ResumeAllThreadsImpl(JSThread *current)
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(threadsLock_);
#else
LockHolder lock(threadsLock_);
#endif
if (suspendNewCount_ > 0) {
suspendNewCount_--;
}

13
ecmascript/runtime.h
View File

@ -31,10 +31,6 @@
#include <list>
#include <memory>
#if defined(ENABLE_FFRT_INTERFACES)
#include "ecmascript/platform/ffrt_mutex.h"
#endif
namespace panda::ecmascript {
class Runtime {
public:
@ -69,11 +65,7 @@ public:
template<class Callback>
void GCIterateThreadList(const Callback &cb)
{
#if defined(ENABLE_FFRT_INTERFACES)
FFRTLockHolder lock(threadsLock_);
#else
LockHolder lock(threadsLock_);
#endif
GCIterateThreadListWithoutLock(cb);
}
@ -271,13 +263,8 @@ private:
return sharedNativePointerCallbacks_;
}
#if defined(ENABLE_FFRT_INTERFACES)
FFRTMutex threadsLock_;
FFRTConditionVariable threadSuspendCondVar_;
#else
Mutex threadsLock_;
ConditionVariable threadSuspendCondVar_;
#endif
Mutex serializeLock_;
std::list<JSThread*> threads_;
uint32_t suspendNewCount_ {0};