| /* |
| * soft_worker.cpp - soft worker implementation |
| * |
| * Copyright (c) 2017 Intel Corporation |
| * |
| * 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. |
| * |
| * Author: Wind Yuan <feng.yuan@intel.com> |
| */ |
| |
| #include "soft_worker.h" |
| #include "thread_pool.h" |
| #include "xcam_mutex.h" |
| |
| namespace XCam { |
| |
| class ItemSynch { |
| private: |
| mutable std::atomic<uint32_t> _remain_items; |
| Mutex _mutex; |
| XCamReturn _error; |
| |
| public: |
| ItemSynch (uint32_t items) |
| : _remain_items(items), _error (XCAM_RETURN_NO_ERROR) |
| {} |
| void update_error (XCamReturn err) { |
| SmartLock locker(_mutex); |
| _error = err; |
| } |
| XCamReturn get_error () { |
| SmartLock locker(_mutex); |
| return _error; |
| } |
| uint32_t dec() { |
| return --_remain_items; |
| } |
| |
| private: |
| XCAM_DEAD_COPY (ItemSynch); |
| }; |
| |
| class WorkItem |
| : public ThreadPool::UserData |
| { |
| public: |
| WorkItem ( |
| const SmartPtr<SoftWorker> &worker, |
| const SmartPtr<Worker::Arguments> &args, |
| const WorkSize &item, |
| SmartPtr<ItemSynch> &sync) |
| : _worker (worker) |
| , _args (args) |
| , _item (item) |
| , _sync (sync) |
| { |
| } |
| virtual XCamReturn run (); |
| virtual void done (XCamReturn err); |
| |
| |
| private: |
| SmartPtr<SoftWorker> _worker; |
| SmartPtr<Worker::Arguments> _args; |
| WorkSize _item; |
| SmartPtr<ItemSynch> _sync; |
| }; |
| |
| XCamReturn |
| WorkItem::run () |
| { |
| XCamReturn ret = _sync->get_error(); |
| if (!xcam_ret_is_ok (ret)) |
| return ret; |
| |
| ret = _worker->work_impl (_args, _item); |
| if (!xcam_ret_is_ok (ret)) |
| _sync->update_error (ret); |
| |
| return ret; |
| } |
| |
| void |
| WorkItem::done (XCamReturn err) |
| { |
| if (_sync->dec () == 0) { |
| XCamReturn ret = _sync->get_error (); |
| if (xcam_ret_is_ok (ret)) |
| ret = err; |
| _worker->all_items_done (_args, ret); |
| } |
| } |
| |
| SoftWorker::SoftWorker (const char *name, const SmartPtr<Callback> &cb) |
| : Worker (name, cb) |
| , _global (1, 1, 1) |
| , _local (1, 1, 1) |
| , _work_unit (1, 1, 1) |
| { |
| } |
| |
| SoftWorker::~SoftWorker () |
| { |
| } |
| |
| bool |
| SoftWorker::set_work_uint (uint32_t x, uint32_t y, uint32_t z) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, x && y && z, false, |
| "SoftWorker(%s) set work unit failed(x:%d, y:%d, z:%d)", |
| XCAM_STR (get_name ()), x, y, z); |
| _work_unit.value[0] = x; |
| _work_unit.value[1] = y; |
| _work_unit.value[2] = z; |
| return true; |
| } |
| |
| bool |
| SoftWorker::set_threads (const SmartPtr<ThreadPool> &threads) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, !_threads.ptr (), false, |
| "SoftWorker(%s) set threads failed, it's already set before.", XCAM_STR (get_name ())); |
| _threads = threads; |
| return true; |
| } |
| |
| bool |
| SoftWorker::set_global_size (const WorkSize &size) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, size.value[0] && size.value[1] && size.value[2], false, |
| "SoftWorker(%s) set global size(x:%d, y:%d, z:%d) failed.", |
| XCAM_STR (get_name ()), size.value[0], size.value[1], size.value[2]); |
| |
| _global = size; |
| return true; |
| } |
| |
| bool |
| SoftWorker::set_local_size (const WorkSize &size) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, size.value[0] && size.value[1] && size.value[2], false, |
| "SoftWorker(%s) set local size(x:%d, y:%d, z:%d) failed.", |
| XCAM_STR (get_name ()), size.value[0], size.value[1], size.value[2]); |
| |
| _local = size; |
| return true; |
| } |
| |
| XCamReturn |
| SoftWorker::stop () |
| { |
| _threads->stop (); |
| return XCAM_RETURN_NO_ERROR; |
| } |
| |
| XCamReturn |
| SoftWorker::work (const SmartPtr<Worker::Arguments> &args) |
| { |
| XCamReturn ret = XCAM_RETURN_NO_ERROR; |
| |
| XCAM_ASSERT (_local.value[0] * _local.value[1] * _local.value[2]); |
| XCAM_ASSERT (_global.value[0] * _global.value[1] * _global.value[2]); |
| |
| WorkSize items; |
| uint32_t max_items = 1; |
| |
| for (uint32_t i = 0; i < SOFT_MAX_DIM; ++i) { |
| items.value[i] = xcam_ceil (_global.value[i], _local.value[i]) / _local.value[i]; |
| max_items *= items.value[i]; |
| } |
| |
| XCAM_FAIL_RETURN ( |
| ERROR, max_items, XCAM_RETURN_ERROR_PARAM, |
| "SoftWorker(%s) max item is zero. work failed.", XCAM_STR (get_name ())); |
| |
| if (max_items == 1) { |
| ret = work_impl (args, WorkSize(0, 0, 0)); |
| status_check (args, ret); |
| return ret; |
| } |
| |
| if (!_threads.ptr ()) { |
| char thr_name [XCAM_MAX_STR_SIZE]; |
| snprintf (thr_name, XCAM_MAX_STR_SIZE, "%s-thrs", XCAM_STR(get_name ())); |
| _threads = new ThreadPool (thr_name); |
| XCAM_ASSERT (_threads.ptr ()); |
| _threads->set_threads (max_items, max_items + 1); //extra thread to process all_items_done |
| ret = _threads->start (); |
| XCAM_FAIL_RETURN ( |
| ERROR, xcam_ret_is_ok (ret), ret, |
| "SoftWorker(%s) work failed when starting threads", XCAM_STR(get_name())); |
| } |
| |
| SmartPtr<ItemSynch> sync = new ItemSynch (max_items); |
| for (uint32_t z = 0; z < items.value[2]; ++z) |
| for (uint32_t y = 0; y < items.value[1]; ++y) |
| for (uint32_t x = 0; x < items.value[0]; ++x) |
| { |
| SmartPtr<WorkItem> item = new WorkItem (this, args, WorkSize(x, y, z), sync); |
| ret = _threads->queue (item); |
| if (!xcam_ret_is_ok (ret)) { |
| //consider half queued but half failed |
| sync->update_error (ret); |
| //status_check (args, ret); // need it here? |
| XCAM_LOG_ERROR ( |
| "SoftWorker(%s) queue work item(x:%d y: %d z:%d) failed", |
| XCAM_STR(get_name()), x, y, z); |
| return ret; |
| } |
| } |
| |
| return XCAM_RETURN_NO_ERROR; |
| } |
| |
| void |
| SoftWorker::all_items_done (const SmartPtr<Arguments> &args, XCamReturn error) |
| { |
| status_check (args, error); |
| } |
| |
| WorkRange |
| SoftWorker::get_range (const WorkSize &item) |
| { |
| WorkRange range; |
| for (uint32_t i = 0; i < SOFT_MAX_DIM; ++i) { |
| range.pos[i] = item.value[i] * _local.value[i]; |
| XCAM_ASSERT (range.pos[i] < _global.value[i]); |
| if (range.pos[i] + _local.value[i] > _global.value[i]) |
| range.pos_len[i] = _global.value[i] - range.pos[i]; |
| else |
| range.pos_len[i] = _local.value[i]; |
| } |
| return range; |
| } |
| |
| XCamReturn |
| SoftWorker::work_impl (const SmartPtr<Arguments> &args, const WorkSize &item) |
| { |
| WorkRange range = get_range (item); |
| return work_range (args, range); |
| } |
| |
| XCamReturn |
| SoftWorker::work_range (const SmartPtr<Arguments> &args, const WorkRange &range) |
| { |
| XCamReturn ret = XCAM_RETURN_NO_ERROR; |
| WorkSize unit; |
| memcpy(unit.value, range.pos, sizeof (unit.value)); |
| |
| for (unit.value[2] = range.pos[2]; unit.value[2] < range.pos[2] + range.pos_len[2]; ++unit.value[2]) |
| for (unit.value[1] = range.pos[1]; unit.value[1] < range.pos[1] + range.pos_len[1]; ++unit.value[1]) |
| for (unit.value[0] = range.pos[0]; unit.value[0] < range.pos[0] + range.pos_len[0]; ++unit.value[0]) { |
| ret = work_unit (args, unit); |
| XCAM_FAIL_RETURN ( |
| ERROR, xcam_ret_is_ok (ret), ret, |
| "SoftWorker(%s) work on pixel(x:%d y: %d z:%d) failed", |
| get_name (), unit.value[0], unit.value[1], unit.value[2]); |
| } |
| |
| return ret; |
| } |
| |
| XCamReturn |
| SoftWorker::work_unit (const SmartPtr<Arguments> &, const WorkSize &) |
| { |
| XCAM_LOG_ERROR ("SoftWorker(%s) work_pixel was not derived. check code"); |
| return XCAM_RETURN_ERROR_PARAM; |
| } |
| |
| }; |