//called by virtual void CLProgram::createKernels(); //those routines build the default arguments list; CLKernel::CLKernel(CLProgram* owningProgram, String kernelName, CLKernelWorkLoadParams* defaultKernelWorkLoadParams, CLKernelArguments* kernelArguments) throw(SimulatorException) : mKernelName(kernelName), mDefaultKernelWorkLoadParams(defaultKernelWorkLoadParams), mCLKernelArguments(kernelArguments) { try { mKernel = cl::Kernel( owningProgram->mCLProgram, kernelName.c_str(), PARA_COMP_MANAGER->getLastCLErrorPtr() ); } catch(cl::Error) { throw(SimulatorException(String("something went wrong when creating the CL kernel ") + kernelName)); } validate(); }
cl::Event CLKernel::run(const EventVector& eventsToWaitFor) throw(SimulatorException) { mCLKernelArguments->passArgsToKernel(this); if( (mDefaultKernelWorkLoadParams->mNumTotalWorkItems == 0 ) || (mDefaultKernelWorkLoadParams->mNumWorkItemsPerWorkGroup == 0 ) ) { throw(SimulatorException("mDefaultKernelWorkLoadParams to be used are invalid! provide custom params!")); } *(PARA_COMP_MANAGER->getLastCLErrorPtr()) = PARA_COMP_MANAGER->getCommandQueue().enqueueNDRangeKernel( mKernel, cl::NullRange, cl::NDRange( (size_t) ( mDefaultKernelWorkLoadParams->mNumTotalWorkItems) ), cl::NDRange( (size_t) ( mDefaultKernelWorkLoadParams->mNumWorkItemsPerWorkGroup) ), & eventsToWaitFor, //PARA_COMP_MANAGER->getLastEventPtr() & mEventOfLastKernelExecution ); //assign this event to global last event, if anyone is interested in it (don't know yet ;( ); *(PARA_COMP_MANAGER->getLastEventPtr()) = mEventOfLastKernelExecution; return mEventOfLastKernelExecution; ; }
void SimulatorRemoteResourceImpl::observe(ObserveType type, ObserveNotificationCallback callback) { if (!callback) { OC_LOG(ERROR, TAG, "Invalid callback!"); throw InvalidArgsException(SIMULATOR_INVALID_CALLBACK, "Invalid callback!"); } std::lock_guard<std::mutex> lock(m_observeMutex); if (m_observeState) { OC_LOG(WARNING, TAG, "Resource already in observe state !"); throw SimulatorException(SIMULATOR_ERROR, "Resource is already being observed!"); } OC::ObserveCallback observeCallback = [this, callback](const OC::HeaderOptions & headerOptions, const OC::OCRepresentation & rep, const int errorCode, const int sequenceNum) { // Convert OCRepresentation to SimulatorResourceModel SimulatorResourceModelSP repModel = SimulatorResourceModel::create(rep); callback(m_id, static_cast<SimulatorResult>(errorCode), repModel, sequenceNum); }; OC::ObserveType observeType = OC::ObserveType::Observe; if (type == ObserveType::OBSERVE_ALL) { observeType = OC::ObserveType::ObserveAll; } try { OCStackResult ocResult = m_ocResource->observe(observeType, OC::QueryParamsMap(), observeCallback); if (OC_STACK_OK != ocResult) { throw SimulatorException(static_cast<SimulatorResult>(ocResult), OC::OCException::reason(ocResult)); } } catch (OC::OCException &e) { throw SimulatorException(static_cast<SimulatorResult>(e.code()), e.reason()); } m_observeState = true; }
void SimulatorRemoteResourceImpl::cancelObserve() { try { OCStackResult ocResult = m_ocResource->cancelObserve(OC::QualityOfService::HighQos); if (OC_STACK_OK != ocResult) throw SimulatorException(static_cast<SimulatorResult>(ocResult), OC::OCException::reason(ocResult)); SIM_LOG(ILogger::INFO, "OBSERVE CANCEL request sent"); } catch (OC::OCException &e) { throw SimulatorException(static_cast<SimulatorResult>(e.code()), e.reason()); } std::lock_guard<std::mutex> lock(m_observeLock); m_observeState = false; }
void SimulatorRemoteResourceImpl::cancelObserve() { try { OCStackResult ocResult = m_ocResource->cancelObserve(OC::QualityOfService::HighQos); if (OC_STACK_OK != ocResult) { throw SimulatorException(static_cast<SimulatorResult>(ocResult), OC::OCException::reason(ocResult)); } } catch (OC::OCException &e) { throw SimulatorException(static_cast<SimulatorResult>(e.code()), e.reason()); } std::lock_guard<std::mutex> lock(m_observeMutex); m_observeState = false; }
void SimulatorRemoteResourceImpl::observe(ObserveType type, ObserveNotificationCallback callback) { VALIDATE_CALLBACK(callback) std::lock_guard<std::mutex> lock(m_observeLock); if (m_observeState) { throw SimulatorException(SIMULATOR_ERROR, "Resource is already being observed!"); } OC::ObserveCallback observeCallback = std::bind( [](const OC::HeaderOptions & headerOptions, const OC::OCRepresentation & ocRep, const int errorCode, const int sqNum, std::string id, ObserveNotificationCallback callback) { SIM_LOG(ILogger::INFO, "Observe response received..." << "\n" << getPayloadString(ocRep)); SimulatorResourceModelSP resourceModel( new SimulatorResourceModel(SimulatorResourceModel::build(ocRep))); callback(id, static_cast<SimulatorResult>(errorCode), resourceModel, sqNum); }, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, m_id, callback); OC::ObserveType observeType = OC::ObserveType::Observe; if (type == ObserveType::OBSERVE_ALL) observeType = OC::ObserveType::ObserveAll; try { OCStackResult ocResult = m_ocResource->observe(observeType, OC::QueryParamsMap(), observeCallback); if (OC_STACK_OK != ocResult) throw SimulatorException(static_cast<SimulatorResult>(ocResult), OC::OCException::reason(ocResult)); SIM_LOG(ILogger::INFO, "OBSERVE request sent"); } catch (OC::OCException &e) { throw SimulatorException(static_cast<SimulatorResult>(e.code()), e.reason()); } m_observeState = true; }
std::shared_ptr<SimulatorResource> SimulatorManager::createResource( const std::string &configPath) { VALIDATE_INPUT(configPath.empty(), "Empty path!") std::shared_ptr<SimulatorResource> resource = SimulatorResourceFactory::getInstance()->createResource(configPath); if (!resource) throw SimulatorException(SIMULATOR_ERROR, "Failed to create resource!"); return resource; }
std::vector<std::shared_ptr<SimulatorResource>> SimulatorManager::createResource( const std::string &configPath, unsigned int count) { VALIDATE_INPUT(configPath.empty(), "Empty path!") VALIDATE_INPUT(!count, "Count is zero!") std::vector<std::shared_ptr<SimulatorResource>> resources = SimulatorResourceFactory::getInstance()->createResource(configPath, count); if (!resources.size()) throw SimulatorException(SIMULATOR_ERROR, "Failed to create resource!"); return resources; }
void SimulatorSingleResourceImpl::setInterface(const std::string &interfaceType) { VALIDATE_INPUT(interfaceType.empty(), "Interface type list is empty!") std::lock_guard<std::recursive_mutex> lock(m_objectLock); if (m_resourceHandle) { throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED, "Resource interface can not be reset when resource is started!"); } m_interfaces = {interfaceType}; }
void SimulatorSingleResourceImpl::setURI(const std::string &uri) { VALIDATE_INPUT(uri.empty(), "Uri is empty!") std::lock_guard<std::recursive_mutex> lock(m_objectLock); if (m_resourceHandle) { throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED, "URI can not be set when resource is started!"); } m_uri = uri; }
void SimulatorSingleResourceImpl::setName(const std::string &name) { VALIDATE_INPUT(name.empty(), "Name is empty!") std::lock_guard<std::recursive_mutex> lock(m_objectLock); if (m_resourceHandle) { throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED, "Name can not be set when resource is started!"); } m_name = name; }
void SimulatorSingleResourceImpl::setInterface(const std::vector<std::string> &interfaceTypes) { VALIDATE_INPUT(interfaceTypes.empty(), "Interface type list is empty!") std::lock_guard<std::recursive_mutex> lock(m_objectLock); if (m_resourceHandle) { throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED, "Resource interface can not be reset when resource is started!"); } m_interfaces.clear(); for (auto &interfaceType : interfaceTypes) { if (m_interfaces.end() == std::find(m_interfaces.begin(), m_interfaces.end(), interfaceType)) { m_interfaces.push_back(interfaceType); } } }
void POSTRequestGenerator::startSending() { // Check the representation if (!m_rep) { OC_LOG(ERROR, TAG, "Invalid Representation given!"); throw SimulatorException(SIMULATOR_ERROR, "Invalid representation detected!"); } // Check if the operation is already in progress std::lock_guard<std::mutex> lock(m_statusLock); if (m_status) { OC_LOG(ERROR, TAG, "Operation already in progress !"); throw OperationInProgressException("Another POST request generation session is already in progress!"); } // Create thread and start sending requests in dispatched thread m_thread = std::make_shared<std::thread>(&POSTRequestGenerator::SendAllRequests, this); m_status = true; m_thread->detach(); }