//-----------------------------------------------------------------------
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());
}
