Lines Matching refs:worker

27 #include "worker.h"

197     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

198     worker->workerEnv_ = nullptr;

201     taskManager.workers_.insert(worker);

204     worker->workerEnv_ = env;

205     worker->state_ = WorkerState::RUNNING;

206     worker->startTime_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;

207     worker->idleState_ = true;

210     worker->state_ = WorkerState::RUNNING;

211     worker->startTime_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;

212     worker->idleState_ = false;

213     worker->hasLongTask_ = true;

216     worker->state_ = WorkerState::RUNNING;

217     worker->startTime_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;

218     worker->idleState_ = false;

219     worker->hasLongTask_ = false;

220     taskManager.idleWorkers_.insert(worker);

235     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

236     worker->workerEnv_ = env;

237     taskManager.idleWorkers_.insert(worker);

239     taskManager.freeList_.emplace_back(worker);

240     worker->state_ = WorkerState::RUNNING;

244     taskManager.idleWorkers_.insert(worker);

245     taskManager.freeList_.emplace_back(worker);

246     worker->idlePoint_ = ConcurrentHelper::GetMilliseconds();

247     worker->state_ = WorkerState::IDLE;

248     worker->hasLongTask_ = false;

252     taskManager.idleWorkers_.insert(worker);

253     taskManager.freeList_.emplace_back(worker);

254     worker->idlePoint_ = ConcurrentHelper::GetMilliseconds() - MAX_TIMEOUT_TIME;

255     worker->state_ = WorkerState::IDLE;

256     worker->hasLongTask_ = false;

257     uv_loop_t* loop = worker->GetWorkerLoop();

258     ConcurrentHelper::UvHandleInit(loop, worker->clearWorkerSignal_, NativeEngineTest::foo, worker);

311     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

312     worker->workerEnv_ = env;

313     uv_loop_t* loop = worker->GetWorkerLoop();

314     ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);

315     taskManager.idleWorkers_.insert(worker);

367     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

368     worker->workerEnv_ = env;

369     uv_loop_t* loop = worker->GetWorkerLoop();

370     ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);

371     worker->state_ = WorkerState::BLOCKED;

372     taskManager.NotifyWorkerIdle(worker);

373     worker->state_ = WorkerState::IDLE;

374     taskManager.NotifyWorkerIdle(worker);

390     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

391     worker->state_ = WorkerState::RUNNING;

392     taskManager.workers_.insert(worker);

422     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

424     worker->state_ = WorkerState::BLOCKED;

425     taskManager.RestoreWorker(worker);

430     worker->state_ = WorkerState::IDLE;

431     worker->workerEnv_ = env;

432     uv_loop_t* loop = worker->GetWorkerLoop();

433     ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);

434     taskManager.RestoreWorker(worker);

479     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

480     worker->workerEnv_ = env;

481     task->worker_ = worker;

740     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

743     worker->workerEnv_ = workerEnv;

745     uv_loop_t* loop = worker->GetWorkerLoop();

746     ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_,

747                                    NativeEngineTest::foo, worker);

748     ConcurrentHelper::UvHandleInit(loop, worker->debuggerOnPostTaskSignal_,

749                                    NativeEngineTest::foo, worker);

750     ConcurrentHelper::UvHandleInit(loop, worker->clearWorkerSignal_,

751                                    NativeEngineTest::foo, worker);

753     req->data = worker;

760     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

761     uv_loop_t* loop = worker->GetWorkerLoop();

762     ConcurrentHelper::UvHandleInit(loop, worker->debuggerOnPostTaskSignal_,

763                                    NativeEngineTest::foo, worker);

767     worker->DebuggerOnPostTask(std::move(myTask));

772     worker->debuggerQueue_.push(myTask1);

773     req->data = worker;

774     worker->debuggerMutex_.unlock();

776     worker->workerEnv_ = nullptr;

777     worker->ReleaseWorkerThreadContent();

780     worker->workerEnv_ = workerEnv;

781     worker->hostEnv_ = nullptr;

782     worker->state_ = WorkerState::BLOCKED;

783     worker->ReleaseWorkerThreadContent();

786     worker->hostEnv_ = env;

787     worker->workerEnv_ = workerEnv1;

788     worker->state_ = WorkerState::IDLE;

789     worker->ReleaseWorkerThreadContent();

796     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

799     worker->workerEnv_ = workerEnv;

819     req->data = worker;

830     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

833     task->env_ = worker->workerEnv_;

834     uv_loop_t* loop = worker->GetWorkerLoop();

838     worker->currentTaskId_.push_back(task1->taskId_);

839     task->worker_ = worker;

849     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

852     task->env_ = worker->workerEnv_;

854     task->worker_ = worker;

856     Worker::TaskResultCallback(worker->workerEnv_, nullptr, false, reinterpret_cast<void*>(task));

859     Worker::TaskResultCallback(worker->workerEnv_, nullptr, true, reinterpret_cast<void*>(task));

861     worker->priority_ = Priority::LOW;

862     worker->ResetWorkerPriority();

865     worker->priority_ = Priority::HIGH;

866     worker->ResetWorkerPriority();

868     worker->state_ = WorkerState::BLOCKED;

869     worker->UpdateExecutedInfo();

870     worker->state_ = WorkerState::IDLE;

871     worker->UpdateExecutedInfo();

875     worker->longTasksSet_ = std::move(set);

876     worker->TerminateTask(task->taskId_);

882     Worker* worker = reinterpret_cast<Worker*>(WorkerConstructor(env));

885     worker->workerEnv_ = workerEnv;

894     task->worker_ = worker;

903     Worker* worker = Worker::WorkerConstructor(env);

905     uv_loop_t* loop = worker->GetWorkerLoop();

906     ConcurrentHelper::UvHandleInit(loop, worker->performTaskSignal_, NativeEngineTest::foo, worker);

907     return worker;

912     Worker* worker = reinterpret_cast<Worker*>(handle->data);

913     return worker->tid_;