int main(int argc, char** argv) { std::wcout << accelerator(accelerator::default_accelerator).description << std::endl; if(argc > 1) { Simulate(argv[1]); } return 0; }
int main(int argc, char** argv) { std::wcout << accelerator(accelerator::default_accelerator).description << std::endl; if(argc > 1) { Simulate(argv[1]); } else { Simulate("C:\\simulation_json\\Data0.json"); } return 0; }
/** ******************************************************************************** * @fn setDefaultAccelerator * @brief Set a default accelerator *******************************************************************************/ int setDefaultAccelerator() { std::vector<accelerator> allAccl = accelerator::get_all(); /************************************************************************** * if deviceID is not set, the default accelerator is AMD Readon * **************************************************************************/ if(!enableDeviceId) { for (unsigned i = 0; i < allAccl.size(); ++i) { if (allAccl[i].get_description().find(L"AMD Radeon") != std::wstring::npos || allAccl[i].get_description().find(L"ATI Radeon") != std::wstring::npos ) { deviceAccl = allAccl[i]; break; } } } else { deviceAccl = allAccl[deviceId]; } accelerator::set_default(deviceAccl.device_path); std::wcout << L"Selected accelerator : " << deviceAccl.get_description() << std::endl; if (deviceAccl == accelerator(accelerator::direct3d_ref)) { std::cout << "WARNING!! Running on very slow emulator!" << std::endl; } if(deviceAccl == accelerator(accelerator::cpu_accelerator)) { std::cout << "There is no need to run on single CPU !"<<std::endl; return SDK_FAILURE; } return SDK_SUCCESS; }
void main(int argc, char *argv[]) { try { IAccelerator accelerator(QF_ID); QuickFlick::initialize(); movieFrame = new MovieFrame; if (argc > 1) movieFrame->setMovie(argv[1]); else movieFrame->showWindow(); IApplication::current().run(); delete movieFrame; QuickFlick::shutdown(); } catch (IException ie) { } }
int SPMV<T>::runArray_View() { array_view<T, 1> *dCSRVals = NULL; array_view<T, 1> *dELLPACKRVals = NULL; array_view<int,1> *dCSRCols = NULL; array_view<int,1> *dCSRRows = NULL; array_view<int,1> *dELLPACKRCols = NULL; array_view<int,1> *dELLPACKRRows = NULL; int status = SDK_SUCCESS; storeArrayOut.resize(denseEdge); if(Layout == SparseLayout::CSR) { dCSRVals = new array_view<T, 1> (nNonZeros, csrVals); dCSRCols = new array_view<int,1> (nNonZeros, csrCols); dCSRRows = new array_view<int,1> (denseEdge + 1, csrRows); } else { dELLPACKRVals = new array_view<T, 1> (ellpackrRowMax * denseEdge, ellpackrVals); dELLPACKRCols = new array_view<int,1> (ellpackrRowMax * denseEdge, ellpackrCols); dELLPACKRRows = new array_view<int,1> (denseEdge, ellpackrRows); } array_view<T, 1> dInVector (denseEdge, inVector); array_view<T, 1> dOutVector(denseEdge,storeArrayOut); // accelerator view for synchronize accelerator_view &accView = accelerator().default_view; //warm up if(Layout == SparseLayout::CSR) { SPMVCSR(*dCSRVals, *dCSRCols, *dCSRRows, dInVector, dOutVector, denseEdge, nNonZeros); } else { SPMVELLPACKR(*dELLPACKRVals, *dELLPACKRCols, *dELLPACKRRows, dInVector, dOutVector, denseEdge); } dOutVector.synchronize(); //calculate total time int timer = sampleTimer->createTimer(); status = sampleTimer->resetTimer(timer); status = sampleTimer->startTimer(timer); for(int run = 0; run < iter; ++run) { // Execute and time the kernel. if(Layout == SparseLayout::CSR) { SPMVCSR(*dCSRVals, *dCSRCols, *dCSRRows, dInVector, dOutVector, denseEdge, nNonZeros); } else { SPMVELLPACKR(*dELLPACKRVals, *dELLPACKRCols, *dELLPACKRRows, dInVector, dOutVector, denseEdge); } accView.flush(); } dOutVector.synchronize(); status = sampleTimer->stopTimer(timer); if(status != SDK_SUCCESS) { return SDK_FAILURE; } totalTime = (double)(sampleTimer->readTimer(timer)); if(dCSRVals != NULL) { delete dCSRVals; } if(dCSRCols != NULL) { delete dCSRCols; } if(dCSRRows != NULL) { delete dCSRRows; } if(dELLPACKRVals != NULL) { delete dELLPACKRVals; } if(dELLPACKRCols != NULL) { delete dELLPACKRCols; } if(dELLPACKRRows != NULL) { delete dELLPACKRRows; } return SDK_SUCCESS; }
int SPMV<T>::runArray() { array<T, 1> *dCSRVals = NULL; array<T, 1> *dELLPACKRVals = NULL; array<int,1> *dCSRCols = NULL; array<int,1> *dCSRRows = NULL; array<int,1> *dELLPACKRCols = NULL; array<int,1> *dELLPACKRRows = NULL; int status = SDK_SUCCESS; storeArrayOut.resize(denseEdge); //calculate data copy time from cpu tp gpu int ctgTimer = sampleTimer->createTimer(); status = sampleTimer->resetTimer(ctgTimer); status = sampleTimer->startTimer(ctgTimer); if(Layout == SparseLayout::CSR) { dCSRVals = new array<T, 1> (nNonZeros,csrVals.begin()); dCSRCols = new array<int,1> (nNonZeros,csrCols.begin()); dCSRRows = new array<int,1> (denseEdge + 1, csrRows.begin()); } else { dELLPACKRVals = new array<T, 1> (ellpackrRowMax * denseEdge, ellpackrVals.begin()); dELLPACKRCols = new array<int,1> (ellpackrRowMax * denseEdge, ellpackrCols.begin()); dELLPACKRRows = new array<int,1> (denseEdge, ellpackrRows.begin()); } array<T, 1> dInVector (denseEdge, inVector.begin()); array<T, 1> dOutVector(denseEdge); status = sampleTimer->stopTimer(ctgTimer); if(status != SDK_SUCCESS) { return SDK_FAILURE; } cpToDeviceTime = (double)(sampleTimer->readTimer(ctgTimer)); //warm up if(Layout == SparseLayout::CSR) { SPMVCSR(*dCSRVals, *dCSRCols, *dCSRRows, dInVector, dOutVector, denseEdge, nNonZeros); } else { SPMVELLPACKR(*dELLPACKRVals, *dELLPACKRCols, *dELLPACKRRows, dInVector, dOutVector, denseEdge); } accelerator_view &accView = accelerator().default_view; accView.flush(); accView.wait(); //calculate total kernel execute time int timer = sampleTimer->createTimer(); status = sampleTimer->resetTimer(timer); status = sampleTimer->startTimer(timer); for(int run = 0; run < iter; ++run) { // Execute and time the kernel. if(Layout == SparseLayout::CSR) { SPMVCSR(*dCSRVals, *dCSRCols, *dCSRRows, dInVector, dOutVector, denseEdge, nNonZeros); } else { SPMVELLPACKR(*dELLPACKRVals, *dELLPACKRCols, *dELLPACKRRows, dInVector, dOutVector, denseEdge); } accView.flush(); } accView.wait(); status = sampleTimer->stopTimer(timer); if(status != SDK_SUCCESS) { return SDK_FAILURE; } totalKernelTime = (double)(sampleTimer->readTimer(timer)); averageKernelTime = totalKernelTime / iter; //calculate data copy time from gpu to cpu int gtcTimer = sampleTimer->createTimer(); status = sampleTimer->resetTimer(gtcTimer); status = sampleTimer->startTimer(gtcTimer); copy(dOutVector, storeArrayOut.begin()); status = sampleTimer->stopTimer(gtcTimer); if(status != SDK_SUCCESS) { return SDK_FAILURE; } cpToHostTime = (double)(sampleTimer->readTimer(gtcTimer)); totalTime = cpToDeviceTime + totalKernelTime + cpToHostTime; if(dCSRVals != NULL) { delete dCSRVals; } if(dCSRCols != NULL) { delete dCSRCols; } if(dCSRRows != NULL) { delete dCSRRows; } if(dELLPACKRVals != NULL) { delete dELLPACKRVals; } if(dELLPACKRCols != NULL) { delete dELLPACKRCols; } if(dELLPACKRRows != NULL) { delete dELLPACKRRows; } return SDK_SUCCESS; }
bool FocusManager::OnKeyEvent(const KeyEvent& event) { // If the focused view wants to process the key event as is, let it be. // On Linux we always dispatch key events to the focused view first, so // we should not do this check here. See also WidgetGtk::OnKeyEvent(). if(focused_view_ && focused_view_->SkipDefaultKeyEventProcessing(event)) { return true; } // Intercept Tab related messages for focus traversal. // Note that we don't do focus traversal if the root window is not part of the // active window hierarchy as this would mean we have no focused view and // would focus the first focusable view. HWND top_window = widget_->GetNativeView(); HWND active_window = ::GetActiveWindow(); if((active_window==top_window || ::IsChild(active_window, top_window)) && IsTabTraversalKeyEvent(event)) { AdvanceFocus(event.IsShiftDown()); return false; } // Intercept arrow key messages to switch between grouped views. KeyboardCode key_code = event.GetKeyCode(); if(focused_view_ && focused_view_->GetGroup()!=-1 && (key_code==VKEY_UP || key_code==VKEY_DOWN || key_code==VKEY_LEFT || key_code==VKEY_RIGHT)) { bool next = (key_code==VKEY_RIGHT || key_code==VKEY_DOWN); std::vector<View*> views; focused_view_->GetParent()->GetViewsWithGroup( focused_view_->GetGroup(), &views); std::vector<View*>::const_iterator iter = std::find(views.begin(), views.end(), focused_view_); DCHECK(iter != views.end()); int index = static_cast<int>(iter - views.begin()); index += next ? 1 : -1; if(index < 0) { index = static_cast<int>(views.size()) - 1; } else if(index >= static_cast<int>(views.size())) { index = 0; } SetFocusedViewWithReason(views[index], kReasonFocusTraversal); return false; } // Process keyboard accelerators. // If the key combination matches an accelerator, the accelerator is // triggered, otherwise the key event is processed as usual. Accelerator accelerator(event.GetKeyCode(), event.IsShiftDown(), event.IsControlDown(), event.IsAltDown()); if(ProcessAccelerator(accelerator)) { // If a shortcut was activated for this keydown message, do not propagate // the event further. return false; } return true; }