//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createTextureWaveTransformer(TextureUnitState* layer, TextureUnitState::TextureTransformType ttype, WaveformType waveType, Real base, Real frequency, Real phase, Real amplitude) { SharedPtr< ControllerValue<Real> > val; SharedPtr< ControllerFunction<Real> > func; switch (ttype) { case TextureUnitState::TT_TRANSLATE_U: // Target value is a u scroll val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, true)); break; case TextureUnitState::TT_TRANSLATE_V: // Target value is a v scroll val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, false, true)); break; case TextureUnitState::TT_SCALE_U: // Target value is a u scale val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, false, false, true)); break; case TextureUnitState::TT_SCALE_V: // Target value is a v scale val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, false, false, false, true)); break; case TextureUnitState::TT_ROTATE: // Target value is texture coord rotation val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, false, false, false, false, true)); break; } // Create new wave function for alterations func.bind(OGRE_NEW WaveformControllerFunction(waveType, base, frequency, phase, amplitude, true)); return createController(mFrameTimeController, val, func); }
WindowController::WindowController(HWND hWnd, std::shared_ptr<Window> window) : WindowContainerBase (hWnd), mWindow (window), mLayout (hWnd, window), mDefaultId (-1) { mWindow->title.changedEvent.add ([&] { if (getText() != mWindow->title()) { setText (mWindow->title()); } }); mWindow->visible.changedEvent.add ([&] { if (isVisible() != mWindow->visible()) { setVisible (mWindow->visible()); } }); mWindow->defaultButton.changedEvent.add ([&] { updateDefaultButton(); }); mWindow->controls.itemAddedEvent.add ([&] (std::shared_ptr<Control> control) { auto controller = createController (shared_from_this(), control); mResources.insert (std::make_pair (control.get(), controller)); }); mWindow->controls.itemRemovedEvent.add ([&] (std::shared_ptr<Control> control) { auto object = mResources[control.get()]; mResources.erase (control.get()); object->destroy(); }); }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createTextureAnimator(TextureUnitState* layer, Real sequenceTime) { SharedPtr< ControllerValue<Real> > texVal(OGRE_NEW TextureFrameControllerValue(layer)); SharedPtr< ControllerFunction<Real> > animFunc(OGRE_NEW AnimationControllerFunction(sequenceTime)); return createController(mFrameTimeController, texVal, animFunc); }
int main() { testAll(); PetRepo *repo = createRepo(); PetController* ctr = createController(repo); addSamplePets(ctr); startUI(ctr); return 0; }
//----------------------------------------------------------------------------- //! @brief TODO enter a description //! @remark //----------------------------------------------------------------------------- void InputSystem::initialise( const std::string& inputMapFileName, HWND hwnd ) { tinyxml2::XMLDocument actionsDoc; std::string availableActionsFileName = extractPathFromFileName(inputMapFileName) + "AvailableActions.xml"; if (actionsDoc.LoadFile(availableActionsFileName.c_str()) != tinyxml2::XML_NO_ERROR) { MSG_TRACE_CHANNEL("Input system Error", "Failed to load the input mapping file %s", availableActionsFileName.c_str()); } const tinyxml2::XMLElement* element1 = actionsDoc.FirstChildElement(); element1 = element1->FirstChildElement();//Skip the <xml> node for (; element1; element1 = element1->NextSiblingElement()) { const tinyxml2::XMLAttribute* actionNameAttribute = element1->FindAttribute("name"); const tinyxml2::XMLAttribute* actionLngNameAttribute = element1->FindAttribute("lng"); if (actionLngNameAttribute != nullptr) { MSG_TRACE_CHANNEL("Input SYSTEM", "adding actions for: %s with hash %u", actionNameAttribute->Value(), hashString(actionNameAttribute->Value())); m_availableActions.emplace_back(InputActions::ActionType(actionNameAttribute->Value(), actionLngNameAttribute != nullptr ? actionLngNameAttribute->Value() : "")); #ifdef DEBUG m_actionNames.insert(std::make_pair(m_availableActions[m_availableActions.size() - 1],actionNameAttribute->Value())); #endif } } tinyxml2::XMLDocument doc; if (doc.LoadFile(inputMapFileName.c_str()) != tinyxml2::XML_NO_ERROR) { MSG_TRACE_CHANNEL("Input system Error", "Failed to load the input mapping file %s", inputMapFileName.c_str()); } const tinyxml2::XMLElement* element = doc.FirstChildElement(); element = element->FirstChildElement();//Skip the <xml> node for (; element; element = element->NextSiblingElement()) { IInputDevice* controller = createController(stringToControllerType(element->Name())); MSG_TRACE_CHANNEL("INPUT SYSTEM", "controller name: %s", element->Name()); const tinyxml2::XMLAttribute* attribute = element->FindAttribute("input_map"); if (controller != nullptr && attribute != nullptr ) { tinyxml2::XMLDocument inputDoc; std::string buttonMapFileName = std::string(extractPathFromFileName(inputMapFileName) + attribute->Value()); if (inputDoc.LoadFile(buttonMapFileName.c_str()) != tinyxml2::XML_NO_ERROR) { MSG_TRACE_CHANNEL("Input system Error", "Failed to load the input mapping file %s", buttonMapFileName.c_str()); return; } tinyxml2::XMLElement* inputElement = inputDoc.FirstChildElement(); inputElement = inputElement->FirstChildElement();//Skip the <xml> node controller->deserialise(inputElement, *this); controller->initialise(hwnd); } } }
PnpExecutable* ROSLearnInstantiator::createExecutable(const string& name) throw(runtime_error) { if (name == "fakeplan") return new PnpPlan(this,0,"fake"); string actionName, path; ifstream file; unsigned long index = name.find('#'); actionName = name; if (index != string::npos) { // Removing robot information to check if the action is a sub-plan. actionName = actionName.substr(index + 1); } path = planFolder + "/" + actionName + ".pnml"; file.open(path.c_str(),ifstream::in); file.close(); if (file.fail()) { file.clear(ios::failbit); World::w->increaseActionValue(); // Try an action. return new ActionProxy(name); } string txt = planFolder + "/../log/" + actionName + "_.txt"; Controller* controller = createController(txt); delete network; try { network = new PnpPlan(this,reward); planLoader.loadFromPNML(path,network); } catch (const runtime_error&) { string errorString ("No action nor plan with name: "); errorString += name; throw runtime_error(errorString); } return new LearnPlan(*network,controller); }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createGpuProgramTimerParam( GpuProgramParametersSharedPtr params, size_t paramIndex, Real timeFactor) { SharedPtr< ControllerValue<Real> > val; SharedPtr< ControllerFunction<Real> > func; val.bind(OGRE_NEW FloatGpuParameterControllerValue(params, paramIndex)); func.bind(OGRE_NEW ScaleControllerFunction(timeFactor, true)); return createController(mFrameTimeController, val, func); }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createTextureRotater(TextureUnitState* layer, Real speed) { SharedPtr< ControllerValue<Real> > val; SharedPtr< ControllerFunction<Real> > func; // Target value is texture coord rotation val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, false, false, false, false, true)); // Function is simple scale (seconds * speed) // Use -speed since altering texture coords has the reverse visible effect func.bind(OGRE_NEW ScaleControllerFunction(-speed, true)); return createController(mFrameTimeController, val, func); }
void PlayField::setupController() { Animator::instance()->restart(); m_seaView->clear(); m_chat->hide(); // remove welcome screen m_seaView->screen(Sea::Player(0))->fadeOut(); m_seaView->screen(Sea::Player(1))->fadeOut(); delete m_controller; m_controller = createController(); m_menu->setupController(m_controller, 0, m_seaView, m_chat, false); startGame(); }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createTextureUScroller(TextureUnitState* layer, Real uSpeed) { Controller<Real>* ret = 0; if (uSpeed != 0) { SharedPtr< ControllerValue<Real> > uVal; SharedPtr< ControllerFunction<Real> > uFunc; uVal.bind(OGRE_NEW TexCoordModifierControllerValue(layer, true)); // Create function: use -speed since we're altering texture coords so they have reverse effect uFunc.bind(OGRE_NEW ScaleControllerFunction(-uSpeed, true)); ret = createController(mFrameTimeController, uVal, uFunc); } return ret; }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createTextureUVScroller(TextureUnitState* layer, Real speed) { Controller<Real>* ret = 0; if (speed != 0) { SharedPtr< ControllerValue<Real> > val; SharedPtr< ControllerFunction<Real> > func; // We do both scrolls with a single controller val.bind(OGRE_NEW TexCoordModifierControllerValue(layer, true, true)); // Create function: use -speed since we're altering texture coords so they have reverse effect func.bind(OGRE_NEW ScaleControllerFunction(-speed, true)); ret = createController(mFrameTimeController, val, func); } return ret; }
void PlayField::resetupController(bool ask) { Entity* old_opponent = m_controller->findEntity(Sea::Player(1)); if (old_opponent) { old_opponent->setParent(0); } BattleShipsConfiguration oldBSC=m_controller->getBattleShipsConfiguration(); delete m_controller; // create new controller m_controller = createController(); m_controller->setBattleShipsConfiguration(oldBSC); m_menu->setupController(m_controller, old_opponent, m_seaView, m_chat, ask); delete old_opponent; startGame(); }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createTextureVScroller(TextureUnitState* layer, Real vSpeed) { Controller<Real>* ret = 0; if (vSpeed != 0) { SharedPtr< ControllerValue<Real> > vVal; SharedPtr< ControllerFunction<Real> > vFunc; // Set up a second controller for v scroll vVal.bind(OGRE_NEW TexCoordModifierControllerValue(layer, false, true)); // Create function: use -speed since we're altering texture coords so they have reverse effect vFunc.bind(OGRE_NEW ScaleControllerFunction(-vSpeed, true)); ret = createController(mFrameTimeController, vVal, vFunc); } return ret; }
void Pt_MSlider::init() { fetchNewRow(); createController(); createView(); if (this->currentView) { this->m_subject->setView(this->currentView); // transfers ownership to controller } //wait for the resource loading to finish while (MTheme::instance()->hasPendingRequests()) { usleep(100); QCoreApplication::processEvents(); } // create pixmap paintdevice createPaintDevice(); }
/* application entry point */ int main(int argc, char* argv[]) { ALEInterface::disableBufferedIO(); std::cerr << ALEInterface::welcomeMessage() << endl; ALEInterface::createOSystem(theOSystem, theSettings); // Process commandline arguments, which over-ride all possible // config file settings string romfile = theOSystem->settings().loadCommandLine(argc, argv); ALEInterface::loadSettings(romfile, theOSystem); // Create the game controller std::string controller_type = theOSystem->settings().getString("game_controller"); std::auto_ptr<ALEController> controller(createController(theOSystem.get(), controller_type)); controller->run(); // MUST delete theOSystem to avoid a segfault (theOSystem relies on Settings // still being a valid construct) theOSystem.reset(NULL); return 0; }
bool WindowController::handleMessage(UINT message, WPARAM wParam, LPARAM lParam, LRESULT& lResult) { switch (message) { case WM_CREATE: { std::shared_ptr<FontResource> fontResource; if (mWindow->font()) { fontResource = createFontResource (mWindow->font()); } else { fontResource = createFontResource (getSystemFont()); } setFontResource (fontResource); // Add owned controls for (auto control : mWindow->controls) { createController (shared_from_this(), control); } // Default button if (mWindow->defaultButton()) { updateDefaultButton(); } break; } case WM_ACTIVATE: { if (wParam == 0) { MessageLoop::getInstance().setActiveWindowHWnd (NULL); } else { MessageLoop::getInstance().setActiveWindowHWnd (mHWnd); } break; } case WM_SETTEXT: { std::string text ((LPCTSTR)lParam); mWindow->title (text); break; } case WM_WINDOWPOSCHANGED: { WINDOWPOS* windowPos = (WINDOWPOS*)lParam; if (!(windowPos->flags & SWP_NOSIZE)) { mWindow->width (windowPos->cx); mWindow->height (windowPos->cy); } if (!(windowPos->flags & SWP_NOMOVE)) { mWindow->left (windowPos->x); mWindow->top (windowPos->y); } break; } case WM_STYLECHANGED: { STYLESTRUCT* styleStruct = (STYLESTRUCT*)lParam; if ((styleStruct->styleOld & WS_VISIBLE) != (styleStruct->styleNew & WS_VISIBLE)) { mWindow->visible (styleStruct->styleNew & WS_VISIBLE); } } case WM_DESTROY: { WindowBase::destroy(); ::PostQuitMessage (0); break; } } return false; }
int train(int cacheSizeInFloats, float *input_data, int *labels, float epsilon, float Ce, float cost, float tolerance, int heuristic, int nPoints, int dFeatures, float paramA, float paramB, float paramC, size_t localInitSize, size_t globalInitSize, int numGroups_foph1, size_t localFoph1Size, size_t globalFoph1Size, size_t localFoph2Size, size_t globalFoph2Size, int numGroups_soph1, size_t localSoph1Size, size_t globalSoph1Size, size_t localSoph2Size, size_t globalSoph2Size, int numGroups_soph3, size_t localSoph3Size, size_t globalSoph3Size, size_t localSoph4Size, size_t globalSoph4Size, cl_mem d_input_data, cl_mem d_input_data_colmajor, cl_mem d_labels, cl_mem d_trainingAlpha, cl_mem d_kernelDiag, cl_mem d_F, cl_mem d_highFsFO, cl_mem d_highIndicesFO, cl_mem d_lowFsFO, cl_mem d_lowIndicesFO, cl_mem d_highFsSO1, cl_mem d_highIndicesSO1, cl_mem d_lowFsSO3, cl_mem d_lowIndicesSO3, cl_mem d_deltaFsSO3, cl_mem d_results, cl_mem d_cache, cl_command_queue queue, cl_kernel init, cl_kernel step1, cl_kernel foph1, cl_kernel foph2, cl_kernel soph1, cl_kernel soph2, cl_kernel soph3, cl_kernel soph4, float *p_rho, int *p_nSV, int *p_iterations, float **p_signedAlpha, float **p_supportVectors){ int numCacheLines = cacheSizeInFloats/nPoints; Cache *cache = createCache(nPoints,numCacheLines); Controller *progress = createController(2.0, 64 ,nPoints); int err; err = 0; err |= clSetKernelArg(init, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(init, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(init, 2, sizeof(cl_mem), &d_F); err |= clSetKernelArg(init, 3, sizeof(cl_mem), &d_kernelDiag); err |= clSetKernelArg(init, 4, sizeof(int), &nPoints); err |= clSetKernelArg(init, 5, sizeof(int), &dFeatures); err |= clSetKernelArg(init, 6, sizeof(float), ¶mA); err |= clSetKernelArg(init, 7, sizeof(float), ¶mB); err |= clSetKernelArg(init, 8, sizeof(float), ¶mC); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, init, 1, NULL, &globalInitSize, &localInitSize, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel init!\n"); printf("Global Size:%zu, Local Size:%zu\n", globalInitSize, localInitSize); return err; } float bLow; float bHigh; int iLow; int iHigh; float alpha1diff; float alpha2diff; size_t globalStep1Size = 1; size_t localStep1Size = 1; err = 0; err |= clSetKernelArg(step1, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(step1, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(step1, 2, sizeof(cl_mem), &d_trainingAlpha); err |= clSetKernelArg(step1, 3, sizeof(cl_mem), &d_kernelDiag); err |= clSetKernelArg(step1, 4, sizeof(float), &cost); err |= clSetKernelArg(step1, 5, sizeof(int), &nPoints); err |= clSetKernelArg(step1, 6, sizeof(int), &dFeatures); err |= clSetKernelArg(step1, 7, sizeof(float), ¶mA); err |= clSetKernelArg(step1, 8, sizeof(float), ¶mB); err |= clSetKernelArg(step1, 9, sizeof(float), ¶mC); err |= clSetKernelArg(step1, 10, sizeof(cl_mem), &d_results); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, step1, 1, NULL, &globalStep1Size, &localStep1Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel step1!\n"); return err; } err = clFinish(queue); if (err != CL_SUCCESS){ printf("Error: waiting for queue to finish failed\n"); return err; } float results[8]; getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff); int iteration; bool iLowCompute; bool iHighCompute; int iLowCacheIndex; int iHighCacheIndex; int currentHeuristic; // clock_t startTot = clock(), diffTot, diffSoph1, diffSoph2, diffSoph3, diffSoph4, diffGetResults; for (iteration = 0; true; iteration++){ if(heuristic == 2){ currentHeuristic = progress->heuristic; }else{ currentHeuristic = heuristic; } if(bLow <= bHigh + 2 * tolerance){ break; } if ((iteration & 0x7ff) == 0) { printf("iteration: %d; gap: %f\n",iteration, bLow - bHigh); } cacheCall(cache,iHigh, &iHighCacheIndex, &iHighCompute); cacheCall(cache,iLow, &iLowCacheIndex, &iLowCompute); alpha1diff = labels[iHigh] * alpha1diff; alpha2diff = labels[iLow] * alpha2diff; if (currentHeuristic == 0){ // Set the arguments to foph1 // err = 0; err = clSetKernelArg(foph1, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(foph1, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(foph1, 2, sizeof(cl_mem), &d_trainingAlpha); err |= clSetKernelArg(foph1, 3, sizeof(cl_mem), &d_F); err |= clSetKernelArg(foph1, 4, sizeof(cl_mem), &d_lowFsFO); err |= clSetKernelArg(foph1, 5, sizeof(cl_mem), &d_highFsFO); err |= clSetKernelArg(foph1, 6, sizeof(cl_mem), &d_lowIndicesFO); err |= clSetKernelArg(foph1, 7, sizeof(cl_mem), &d_highIndicesFO); err |= clSetKernelArg(foph1, 8, sizeof(int), &nPoints); err |= clSetKernelArg(foph1, 9, sizeof(int), &dFeatures); err |= clSetKernelArg(foph1, 10, sizeof(float), &epsilon); err |= clSetKernelArg(foph1, 11, sizeof(float), &Ce); err |= clSetKernelArg(foph1, 12, sizeof(int), &iHigh); err |= clSetKernelArg(foph1, 13, sizeof(int), &iLow); err |= clSetKernelArg(foph1, 14, sizeof(float), &alpha1diff); err |= clSetKernelArg(foph1, 15, sizeof(float), &alpha2diff); err |= clSetKernelArg(foph1, 16, sizeof(float), ¶mA); err |= clSetKernelArg(foph1, 17, sizeof(float), ¶mB); err |= clSetKernelArg(foph1, 18, sizeof(float), ¶mC); err |= clSetKernelArg(foph1, 19, sizeof(int) * localFoph1Size, NULL); err |= clSetKernelArg(foph1, 20, sizeof(float) * localFoph1Size, NULL); err |= clSetKernelArg(foph1, 21, sizeof(cl_mem), &d_cache); err |= clSetKernelArg(foph1, 22, sizeof(bool), &iHighCompute); err |= clSetKernelArg(foph1, 23, sizeof(bool), &iLowCompute); err |= clSetKernelArg(foph1, 24, sizeof(int), &iHighCacheIndex); err |= clSetKernelArg(foph1, 25, sizeof(int),&iLowCacheIndex); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, foph1, 1, NULL, &globalFoph1Size, &localFoph1Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel Foph1!\n"); return err; } // Set the arguments to foph2 // err = 0; err = clSetKernelArg(foph2, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(foph2, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(foph2, 2, sizeof(cl_mem), &d_trainingAlpha); err |= clSetKernelArg(foph2, 3, sizeof(cl_mem), &d_kernelDiag); err |= clSetKernelArg(foph2, 4, sizeof(cl_mem), &d_lowFsFO); err |= clSetKernelArg(foph2, 5, sizeof(cl_mem), &d_highFsFO); err |= clSetKernelArg(foph2, 6, sizeof(cl_mem), &d_lowIndicesFO); err |= clSetKernelArg(foph2, 7, sizeof(cl_mem), &d_highIndicesFO); err |= clSetKernelArg(foph2, 8, sizeof(cl_mem), &d_results); err |= clSetKernelArg(foph2, 9, sizeof(float), &cost); err |= clSetKernelArg(foph2, 10, sizeof(int), &dFeatures); err |= clSetKernelArg(foph2, 11, sizeof(int), &numGroups_foph1); err |= clSetKernelArg(foph2, 12, sizeof(float), ¶mA); err |= clSetKernelArg(foph2, 13, sizeof(float), ¶mB); err |= clSetKernelArg(foph2, 14, sizeof(float), ¶mC); err |= clSetKernelArg(foph2, 15, sizeof(int) * localFoph2Size, NULL); err |= clSetKernelArg(foph2, 16, sizeof(float) * localFoph2Size, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, foph2, 1, NULL, &globalFoph2Size, &localFoph2Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel Foph2!\n"); return err; } // Wait for the command queue to get serviced before reading back results // err = clFinish(queue); if (err != CL_SUCCESS){ printf("Error: waiting for queue to finish failed\n"); return err; } getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff); }else{ // Set the arguments to soph1 // // clock_t startSoph1 = clock(); err = 0; err = clSetKernelArg(soph1, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(soph1, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(soph1, 2, sizeof(cl_mem), &d_trainingAlpha); err |= clSetKernelArg(soph1, 3, sizeof(cl_mem), &d_F); err |= clSetKernelArg(soph1, 4, sizeof(cl_mem), &d_highFsSO1); err |= clSetKernelArg(soph1, 5, sizeof(cl_mem), &d_highIndicesSO1); err |= clSetKernelArg(soph1, 6, sizeof(int), &nPoints); err |= clSetKernelArg(soph1, 7, sizeof(int), &dFeatures); err |= clSetKernelArg(soph1, 8, sizeof(float), &epsilon); err |= clSetKernelArg(soph1, 9, sizeof(float), &Ce); err |= clSetKernelArg(soph1, 10, sizeof(int), &iHigh); err |= clSetKernelArg(soph1, 11, sizeof(int), &iLow); err |= clSetKernelArg(soph1, 12, sizeof(float), &alpha1diff); err |= clSetKernelArg(soph1, 13, sizeof(float), &alpha2diff); err |= clSetKernelArg(soph1, 14, sizeof(float), ¶mA); err |= clSetKernelArg(soph1, 15, sizeof(float), ¶mB); err |= clSetKernelArg(soph1, 16, sizeof(float), ¶mC); err |= clSetKernelArg(soph1, 17, sizeof(int) * localSoph1Size, NULL); err |= clSetKernelArg(soph1, 18, sizeof(float) * localSoph1Size, NULL); err |= clSetKernelArg(soph1, 19, sizeof(cl_mem), &d_cache); err |= clSetKernelArg(soph1, 20, sizeof(bool), &iHighCompute); err |= clSetKernelArg(soph1, 21, sizeof(bool), &iLowCompute); err |= clSetKernelArg(soph1, 22, sizeof(int), &iHighCacheIndex); err |= clSetKernelArg(soph1, 23, sizeof(int),&iLowCacheIndex); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, soph1, 1, NULL, &globalSoph1Size, &localSoph1Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel Soph1!\n"); return err; } // clFinish(queue); // diffSoph1 = clock() - startSoph1; // clock_t startSoph2 = clock(); // Set the arguments to soph2 // err = 0; err |= clSetKernelArg(soph2, 0, sizeof(cl_mem), &d_highFsSO1); err |= clSetKernelArg(soph2, 1, sizeof(cl_mem), &d_highIndicesSO1); err |= clSetKernelArg(soph2, 2, sizeof(cl_mem), &d_results); err |= clSetKernelArg(soph2, 3, sizeof(int), &numGroups_soph1); err |= clSetKernelArg(soph2, 4, sizeof(int) * localSoph2Size, NULL); err |= clSetKernelArg(soph2, 5, sizeof(float) * localSoph2Size, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, soph2, 1, NULL, &globalSoph2Size, &localSoph2Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel Soph2!\n"); return err; } // clFinish(queue); // diffSoph2 = clock() - startSoph2; // Set the arguments to soph3 // clFinish(queue); getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff); // clock_t startSoph3 = clock(); cacheCall(cache, iHigh, &iHighCacheIndex, &iHighCompute); err = 0; err = clSetKernelArg(soph3, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(soph3, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(soph3, 2, sizeof(cl_mem), &d_trainingAlpha); err |= clSetKernelArg(soph3, 3, sizeof(cl_mem), &d_F); err |= clSetKernelArg(soph3, 4, sizeof(cl_mem), &d_kernelDiag); err |= clSetKernelArg(soph3, 5, sizeof(cl_mem), &d_lowFsSO3); err |= clSetKernelArg(soph3, 6, sizeof(cl_mem), &d_lowIndicesSO3); err |= clSetKernelArg(soph3, 7, sizeof(cl_mem), &d_deltaFsSO3); err |= clSetKernelArg(soph3, 8, sizeof(cl_mem), &d_results); err |= clSetKernelArg(soph3, 9, sizeof(int), &iHigh); err |= clSetKernelArg(soph3, 10, sizeof(float), &bHigh); err |= clSetKernelArg(soph3, 11, sizeof(int), &nPoints); err |= clSetKernelArg(soph3, 12, sizeof(int), &dFeatures); err |= clSetKernelArg(soph3, 13, sizeof(float), &epsilon); err |= clSetKernelArg(soph3, 14, sizeof(float), &Ce); err |= clSetKernelArg(soph3, 15, sizeof(float), ¶mA); err |= clSetKernelArg(soph3, 16, sizeof(float), ¶mB); err |= clSetKernelArg(soph3, 17, sizeof(float), ¶mC); err |= clSetKernelArg(soph3, 18, sizeof(int) * localSoph3Size, NULL); err |= clSetKernelArg(soph3, 19, sizeof(float) * localSoph3Size, NULL); err |= clSetKernelArg(soph3, 20, sizeof(cl_mem), &d_cache); err |= clSetKernelArg(soph3, 21, sizeof(bool), &iHighCompute); err |= clSetKernelArg(soph3, 22, sizeof(int), &iHighCacheIndex); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, soph3, 1, NULL, &globalSoph3Size, &localSoph3Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel Soph3!\n"); return err; } // clFinish(queue); // diffSoph3 = clock() - startSoph3; // Set the arguments to soph4 // // clock_t startSoph4 = clock(); err = 0; err = clSetKernelArg(soph4, 0, sizeof(cl_mem), &d_input_data); err |= clSetKernelArg(soph4, 1, sizeof(cl_mem), &d_labels); err |= clSetKernelArg(soph4, 2, sizeof(cl_mem), &d_trainingAlpha); err |= clSetKernelArg(soph4, 3, sizeof(cl_mem), &d_kernelDiag); err |= clSetKernelArg(soph4, 4, sizeof(cl_mem), &d_lowFsSO3); err |= clSetKernelArg(soph4, 5, sizeof(cl_mem), &d_lowIndicesSO3); err |= clSetKernelArg(soph4, 6, sizeof(cl_mem), &d_deltaFsSO3); err |= clSetKernelArg(soph4, 7, sizeof(cl_mem), &d_results); err |= clSetKernelArg(soph4, 8, sizeof(float), &cost); err |= clSetKernelArg(soph4, 9, sizeof(int), &dFeatures); err |= clSetKernelArg(soph4, 10, sizeof(int), &numGroups_soph3); err |= clSetKernelArg(soph4, 11, sizeof(float), ¶mA); err |= clSetKernelArg(soph4, 12, sizeof(float), ¶mB); err |= clSetKernelArg(soph4, 13, sizeof(float), ¶mC); err |= clSetKernelArg(soph4, 14, sizeof(cl_mem), &d_F); err |= clSetKernelArg(soph4, 15, sizeof(int) * localSoph4Size, NULL); err |= clSetKernelArg(soph4, 16, sizeof(float) * localSoph4Size, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to set kernel arguments! %d\n", err); return err; } err = clEnqueueNDRangeKernel(queue, soph4, 1, NULL, &globalSoph4Size, &localSoph4Size, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to execute kernel Soph4!\n"); return err; } // clFinish(queue); // diffSoph4 = clock() - startSoph4; // Wait for the command queue to get serviced before reading back results // err = clFinish(queue); if (err != CL_SUCCESS){ printf("Error: waiting for queue to finish failed\n"); return err; } // clock_t startGetResults = clock(); getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff); // clFinish(queue); // diffGetResults = clock() - startGetResults; //printf("iLow:%d, iHigh:%d\n", (int)results[2], (int)results[3]); } if(heuristic == 2){ addIteration(progress, bLow - bHigh); } } printf("INFO: %d iterations\n", iteration); printf("INFO: bLow: %f, bHigh %f\n", bLow, bHigh); // diffTot = clock() - startTot; // float msecTot = diffTot * 1000.0 / CLOCKS_PER_SEC; // printf("Total time taken %.5f milliseconds\n", msecTot); // float msecSoph1 = diffSoph1 * 1000.0 / CLOCKS_PER_SEC; // printf("Soph1 time taken %.5f milliseconds\n", msecSoph1); // float msecSoph2 = diffSoph2 * 1000.0 / CLOCKS_PER_SEC; // printf("Soph2 time taken %.5f milliseconds\n", msecSoph2); // float msecSoph3 = diffSoph3 * 1000.0 / CLOCKS_PER_SEC; // printf("Soph3 time taken %.5f milliseconds\n", msecSoph3); // float msecSoph4 = diffSoph4 * 1000.0 / CLOCKS_PER_SEC; // printf("Soph4 time taken %.5f milliseconds\n", msecSoph4); // float msecGetResults = diffGetResults * 1000.0 / CLOCKS_PER_SEC; // printf("GetResult time taken %.5f milliseconds\n", msecGetResults); // get training alpha float *trainingAlpha = (float *)malloc(sizeof(float) * nPoints); err = clEnqueueReadBuffer(queue, d_trainingAlpha, CL_TRUE, 0, sizeof(float) * nPoints, trainingAlpha, 0, NULL, NULL); if (err != CL_SUCCESS){ printf("Error: Failed to read buffer\n"); return err; } // save results *p_rho = (bHigh + bLow)/2; int nSV = 0; for(int i = 0; i < nPoints; i++){ if (trainingAlpha[i] > epsilon){ nSV++; } } int index = 0; *p_nSV = nSV; *p_supportVectors = (float *)malloc(sizeof(float) * nSV * dFeatures); *p_signedAlpha = (float *)malloc(sizeof(float) * nSV); for(int i = 0; i < nPoints; i++){ if(trainingAlpha[i] > epsilon){ (* p_signedAlpha)[index] = labels[i] * trainingAlpha[i]; for(int j = 0; j < dFeatures; j++){ (* p_supportVectors)[index*dFeatures + j] = input_data[i * dFeatures + j]; } index ++; } } // Shutdown and cleanup // printf("%d Cache Hits!\n",cache->hits); printf("%d Cache Misses!\n",cache->misses); return 0; }
//----------------------------------------------------------------------- Controller<Real>* ControllerManager::createFrameTimePassthroughController( const ControllerValueRealPtr& dest) { return createController(getFrameTimeSource(), dest, getPassthroughControllerFunction()); }