CropTransformer::RatioJitterType CropTransformer::ParseJitterType(const std::string &src) { if (src.empty() || AreEqualIgnoreCase(src, "none")) { return RatioJitterType::None; } if (AreEqualIgnoreCase(src, "uniratio")) { return RatioJitterType::UniRatio; } if (AreEqualIgnoreCase(src, "unilength")) { return RatioJitterType::UniLength; } if (AreEqualIgnoreCase(src, "uniarea")) { return RatioJitterType::UniArea; } RuntimeError("Invalid jitter type: %s.", src.c_str()); }
Cell* eval(Cell* const c) { initialize(c); if (c == nil) throw RuntimeError("Empty list\n : At Cell* eval()"); string s; if (!listp(c) && symbolp(c) && fstack.empty()) throw RuntimeError("Attempt to reference an unbound variable \"" + get_symbol(c) + "\"" + "\n : At Cell* eval()"); else if (!listp(c) && !fstack.empty() && symbolp(c)) { s = get_symbol(c); CellMap::iterator find_key; if (fstack.size() > 1) { find_key = fstack[1].find(s); if (find_key != fstack[1].end()) return ceval(find_key->second); } find_key = fstack[0].find(s); if (find_key == fstack[0].end()) throw RuntimeError("Attempt to reference an unbound variable \"" + s + "\"" + "\n : At Cell* eval()"); return ceval(find_key->second); } if (!listp(c) && !symbolp(c)) return c; else if (listp(c) && !symbolp(car(c)) && !listp(car(c))) throw RuntimeError("Invalid operator\n : At Cell* eval()"); else if (listp(car(c))) { if (nullp(car(c))) throw RuntimeError("Cannot evaluate a null expression\n : At Cell* eval()"); return ceval(c); // pass it to ceval if it's a double list } s = get_symbol(car(c)); vector<string>::iterator find_op = locate(op.begin(), op.end(), s); if (find_op != op.end()) return ceval(c); else if (fstack.size() > 1) { CellMap::iterator find_key = fstack[1].find(s); if (find_key != fstack[1].end()) return ceval(c);// return apply(ceval(find_key->second), cdr(c)); } throw RuntimeError("Invalid operator \"" + s + "\"\n : At Cell* eval()"); }
inline void AssertSameDist( const DistTypeA& distA, const DistTypeB& distB ) { if( distA.colDist != distB.colDist || distA.rowDist != distB.rowDist ) RuntimeError("Matrices must have the same distribution"); }
// all constructors call this void File::Init(const wchar_t* filename, int fileOptions) { m_filename = filename; m_options = fileOptions; if (m_filename.empty()) RuntimeError("File: filename is empty"); const auto outputPipe = (m_filename.front() == '|'); const auto inputPipe = (m_filename.back() == '|'); // translate the options string into a string for fopen() const auto reading = !!(fileOptions & fileOptionsRead); const auto writing = !!(fileOptions & fileOptionsWrite); if (!reading && !writing) RuntimeError("File: either fileOptionsRead or fileOptionsWrite must be specified"); // convert fileOptions to fopen()'s mode string wstring options = reading ? L"r" : L""; if (writing) { // if we already are reading the file, change to read/write options.clear(); options.append(L"w"); if (!outputPipe && m_filename != L"-") { options.append(L"+"); msra::files::make_intermediate_dirs(m_filename.c_str()); // writing to regular file -> also create the intermediate directories as a convenience } } if (fileOptions & fileOptionsBinary) options += L"b"; else options += L"t"; // add sequential flag to allocate big read buffer if (fileOptions & fileOptionsSequential) options += L"S"; // now open the file // Special path syntax understood here: // - "-" refers to stdin or stdout // - "|cmd" writes to a pipe // - "cmd|" reads from a pipe m_pcloseNeeded = false; m_seekable = false; if (m_filename == L"-") // stdin/stdout { if (writing && reading) RuntimeError("File: cannot specify fileOptionsRead and fileOptionsWrite at once with path '-'"); m_file = writing ? stdout : stdin; } else if (outputPipe || inputPipe) // pipe syntax { if (inputPipe && outputPipe) RuntimeError("File: pipes cannot specify fileOptionsRead and fileOptionsWrite at once"); if (inputPipe != reading) RuntimeError("File: pipes must use consistent fileOptionsRead/fileOptionsWrite"); const auto command = inputPipe ? m_filename.substr(0, m_filename.size() - 1) : m_filename.substr(1); m_file = _wpopen(command.c_str(), options.c_str()); if (!m_file) RuntimeError("File: error exexuting pipe command '%S': %s", command.c_str(), strerror(errno)); m_pcloseNeeded = true; } else attempt([=]() // regular file: use a retry loop { m_file = fopenOrDie(filename, options.c_str()); m_seekable = true; }); }
void set_caps_aspect(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) { throw RuntimeError (_T("Sorry, cannot directly set capsule aspect")); }
void AngleControl::add_control(Rollout *ro, HWND parent, HINSTANCE hInstance, int& current_y) { caption = caption->eval(); HWND label; int left, top, width, height; SIZE size; const TCHAR *label_text = caption->eval()->to_string(); parent_rollout = ro; control_ID = next_id(); WORD label_id = next_id(); Value *val; if((val = control_param(diameter)) != &unsupplied) m_diameter = val->to_int(); else if((val = control_param(width)) != &unsupplied) m_diameter = val->to_int(); else if((val = control_param(height)) != &unsupplied) m_diameter = val->to_int(); else m_diameter = 64; val = control_param(degrees); if(val != &unsupplied) m_degrees = val->to_float(); else m_degrees = 0.f; val = control_param(radians); if(val != &unsupplied) m_degrees = RadToDeg(val->to_float()); val = control_param(range); if (val == &unsupplied) { m_min = -360.0f; m_max = 360.0f; } else if (is_point3(val)) { Point3 p = val->to_point3(); m_min = p.x; m_max = p.y; m_degrees = p.z; } else throw TypeError (MaxSDK::GetResourceStringAsMSTR(IDS_ANGLE_RANGE_MUST_BE_A_VECTOR), val); val = control_param(startDegrees); if(val != &unsupplied) SetStartDegrees(val->to_float()); else SetStartDegrees(0.f); val = control_param(startRadians); if(val != &unsupplied) SetStartDegrees(RadToDeg(val->to_float())); val = control_param(dir); if(val != &unsupplied) { if (val != n_CW && val != n_CCW) throw RuntimeError (MaxSDK::GetResourceStringAsMSTR(IDS_ANGLE_DIR_BAD_VALUE), val); m_dirCCW = val != n_CW; } val = control_param(bitmap); if(val != &unsupplied) SetBitmap(val); else SetColor(control_param(color)); m_lButtonDown = FALSE; layout_data pos; compute_layout(ro, &pos, current_y); left = pos.left; top = pos.top; // place optional label int label_height = (_tcslen(label_text) != 0) ? ro->text_height + SPACING_BEFORE - 2 : 0; // LAM - defect 298613 - not creating the caption HWND was causing problems (whole screen redrawn // when control moved, setting caption text set wrong HWND). Now always create. // if (label_height != 0) // { DLGetTextExtent(ro->rollout_dc, label_text, &size); width = min(size.cx, pos.width); height = ro->text_height; label = CreateWindow(_T("STATIC"), label_text, WS_VISIBLE | WS_CHILD | WS_GROUP, left, top, width, height, parent, (HMENU)label_id, hInstance, NULL); // } // place angle box top = pos.top + label_height; width = pos.width; m_hWnd = CreateWindow( ANGLECTRL_WINDOWCLASS, TEXT(""), WS_VISIBLE | WS_CHILD | WS_GROUP, pos.left, top, width, m_diameter, parent, (HMENU)control_ID, g_hInst, this); m_hToolTip = CreateWindow( TOOLTIPS_CLASS, TEXT(""), WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, m_hWnd, (HMENU)NULL, g_hInst, NULL); SendMessage(label, WM_SETFONT, (WPARAM)ro->font, 0L); SendMessage(m_hToolTip, TTM_ADDTOOL, 0, (LPARAM)GetToolInfo()); }
void Object::deserialize( Object *parent , Object *o , SerializeObject& so ) { if( strcmp( so.getEffectiveObjectClass() , o -> getClass() ) ) throw RuntimeError( "Object::deserialize: different object and so classes" ); o -> deserialize( parent , so ); }
String Object::getPK() { throw RuntimeError( "Object::getPK: virtual function undefined for class" ); }
CropTransformer::CropTransformer(const ConfigParameters& config) : ImageTransformerBase(config) { intargvector cropSize = config(L"cropSize", "0"); m_cropWidth = cropSize[0]; m_cropHeight = cropSize[1]; if (m_cropWidth < 0 || m_cropHeight < 0) { RuntimeError("Invalid cropSize value, must be >= 0"); } m_useSideRatio = true; floatargvector sideRatio = config(L"sideRatio", "0.0"); m_sideRatioMin = sideRatio[0]; m_sideRatioMax = sideRatio[1]; if (m_sideRatioMin == 0.0 && m_sideRatioMax == 0.0) // taking default value means not specified { m_useSideRatio = false; } else if (!(m_sideRatioMin > 0 && m_sideRatioMax <= 1.0) || m_sideRatioMin > m_sideRatioMax) { RuntimeError("Invalid sideRatio value, must be > 0 and <= 1. sideMin must <= sideMax"); } m_useAreaRatio = true; floatargvector areaRatio = config(L"areaRatio", "0.0"); m_areaRatioMin = areaRatio[0]; m_areaRatioMax = areaRatio[1]; if (m_areaRatioMin == 0.0 && m_areaRatioMax == 0.0) // taking default value means not specified { m_useAreaRatio = false; } else if (!(m_areaRatioMin > 0 && m_areaRatioMax <= 1.0) || m_areaRatioMin > m_areaRatioMax) { RuntimeError("Invalid areaRatio value, must be > 0 and <= 1. areaMin must <= areaMax"); } if (m_useSideRatio && m_useAreaRatio) RuntimeError("sideRatio and areaRatio cannot be specified simultaneously"); floatargvector aspectRatio = config(L"aspectRatio", "1.0"); m_aspectRatioMin = aspectRatio[0]; m_aspectRatioMax = aspectRatio[1]; if (!(m_aspectRatioMin > 0 && m_aspectRatioMax <= 1.0) || m_aspectRatioMin > m_aspectRatioMax) { RuntimeError("Invalid aspectRatio value, must be > 0 and <= 1. aspectMin must <= aspectMax"); } m_jitterType = ParseJitterType(config(L"jitterType", "")); m_cropType = ImageConfigHelper::ParseCropType(config(L"cropType", "")); if (!config.ExistsCurrent(L"hflip")) { m_hFlip = (m_cropType == CropType::RandomSide || m_cropType == CropType::RandomArea); } else { m_hFlip = config(L"hflip"); } // for MultiView10 we need to set m_hflip = false, otherwise we might not get 5 unflipped image (see CropTransformer::Apply below) if (m_cropType == CropType::MultiView10) { m_hFlip = false; } }
TextConfigHelper::TextConfigHelper(const ConfigParameters& config) { if (!config.ExistsCurrent(L"input")) { RuntimeError("CNTKTextFormatReader configuration does not contain \"input\" section."); } const ConfigParameters& input = config(L"input"); if (input.empty()) { RuntimeError("CNTKTextFormatReader configuration contains an empty \"input\" section."); } string precision = config.Find("precision", "float"); if (AreEqualIgnoreCase(precision, "double")) { m_elementType = ElementType::tdouble; } else if (AreEqualIgnoreCase(precision, "float")) { m_elementType = ElementType::tfloat; } else { RuntimeError("Not supported precision '%s'. Expected 'double' or 'float'.", precision.c_str()); } StreamId id = 0; map<string, wstring> aliasToInputMap; for (const pair<string, ConfigParameters>& section : input) { ConfigParameters input = section.second; wstring name = msra::strfun::utf16(section.first); if (!input.ExistsCurrent(L"dim") || !input.ExistsCurrent(L"format")) { RuntimeError("Input section for input '%ls' does not specify all the required parameters, " "\"dim\" and \"format\".", name.c_str()); } StreamDescriptor stream; stream.m_id = id++; stream.m_name = name; stream.m_sampleDimension = input(L"dim"); string type = input(L"format"); if (AreEqualIgnoreCase(type, "dense")) { stream.m_storageType = StorageType::dense; } else if (AreEqualIgnoreCase(type, "sparse")) { stream.m_storageType = StorageType::sparse_csc; if (stream.m_sampleDimension > numeric_limits<IndexType>::max()) { RuntimeError("Sample dimension (%" PRIu64 ") for sparse input '%ls'" " exceeds the maximum allowed value (%" PRIu64 ").\n", stream.m_sampleDimension, name.c_str(), (size_t)numeric_limits<IndexType>::max()); } } else { RuntimeError("'format' parameter must be set either to 'dense' or 'sparse'."); } // alias is optional if (input.ExistsCurrent(L"alias")) { stream.m_alias = input(L"alias"); if (stream.m_alias.empty()) { RuntimeError("Alias value for input '%ls' is empty.", name.c_str()); } } else { stream.m_alias = section.first; } if (aliasToInputMap.find(stream.m_alias) != aliasToInputMap.end()) { RuntimeError("Alias %s is already mapped to input %ls.", stream.m_alias.c_str(), aliasToInputMap[stream.m_alias].c_str()); } else { aliasToInputMap[stream.m_alias] = stream.m_name; } stream.m_elementType = m_elementType; m_streams.push_back(stream); } m_filepath = msra::strfun::utf16(config(L"file")); if (config.Exists(L"randomize")) { wstring randomizeString = config.CanBeString(L"randomize") ? config(L"randomize") : wstring(); if (!_wcsicmp(randomizeString.c_str(), L"none")) { m_randomizationWindow = randomizeNone; } else if (!_wcsicmp(randomizeString.c_str(), L"auto")) { m_randomizationWindow = randomizeAuto; } else { m_randomizationWindow = config(L"randomize"); } } else { m_randomizationWindow = randomizeAuto; } m_skipSequenceIds = config(L"skipSequenceIds", false); m_maxErrors = config(L"maxErrors", 0); m_traceLevel = config(L"traceLevel", 0); m_chunkSizeBytes = config(L"chunkSizeInBytes", 32 * 1024 * 1024); // 32 MB by default m_chunkCacheSize = config(L"numChunksToCache", 32); // 32 * 32 MB = 1 GB of memory in total }
void MatrixMarket( Matrix<T>& A, const string filename ) { EL_DEBUG_CSE typedef Base<T> Real; std::ifstream file( filename.c_str() ); if( !file.is_open() ) RuntimeError("Could not open ",filename); // Read the header // =============== // Attempt to pull in the various header components // ------------------------------------------------ string line, stamp, object, format, field, symmetry; if( !std::getline( file, line ) ) RuntimeError("Could not extract header line"); { std::stringstream lineStream( line ); lineStream >> stamp; if( stamp != string("%%MatrixMarket") ) RuntimeError("Invalid Matrix Market stamp: ",stamp); if( !(lineStream >> object) ) RuntimeError("Missing Matrix Market object"); if( !(lineStream >> format) ) RuntimeError("Missing Matrix Market format"); if( !(lineStream >> field) ) RuntimeError("Missing Matrix Market field"); if( !(lineStream >> symmetry) ) RuntimeError("Missing Matrix Market symmetry"); } // Ensure that the header components are individually valid // -------------------------------------------------------- const bool isMatrix = ( object == string("matrix") ); const bool isArray = ( format == string("array") ); const bool isComplex = ( field == string("complex") ); const bool isPattern = ( field == string("pattern") ); const bool isGeneral = ( symmetry == string("general") ); const bool isSymmetric = ( symmetry == string("symmetric") ); const bool isSkewSymmetric = ( symmetry == string("skew-symmetric") ); const bool isHermitian = ( symmetry == string("hermitian") ); if( !isMatrix && object != string("vector") ) RuntimeError("Invalid Matrix Market object: ",object); if( !isArray && format != string("coordinate") ) RuntimeError("Invalid Matrix Market format: ",format); if( !isComplex && !isPattern && field != string("real") && field != string("double") && field != string("integer") ) RuntimeError("Invalid Matrix Market field: ",field); if( !isGeneral && !isSymmetric && !isSkewSymmetric && !isHermitian ) RuntimeError("Invalid Matrix Market symmetry: ",symmetry); // Ensure that the components are consistent // ----------------------------------------- if( isArray && isPattern ) RuntimeError("Pattern field requires coordinate format"); // NOTE: This constraint is only enforced because of the note located at // http://people.sc.fsu.edu/~jburkardt/data/mm/mm.html if( isSkewSymmetric && isPattern ) RuntimeError("Pattern field incompatible with skew-symmetry"); if( isHermitian && !isComplex ) RuntimeError("Hermitian symmetry requires complex data"); // Skip the comment lines // ====================== while( file.peek() == '%' ) std::getline( file, line ); int m, n; if( !std::getline( file, line ) ) RuntimeError("Could not extract the size line"); if( isArray ) { // Read in the matrix dimensions // ============================= if( isMatrix ) { std::stringstream lineStream( line ); if( !(lineStream >> m) ) RuntimeError("Missing matrix height: ",line); if( !(lineStream >> n) ) RuntimeError("Missing matrix width: ",line); } else { std::stringstream lineStream( line ); if( !(lineStream >> m) ) RuntimeError("Missing vector height: ",line); n = 1; } // Resize the matrix // ================= Zeros( A, m, n ); // Now read in the data // ==================== Real realPart, imagPart; for( Int j=0; j<n; ++j ) { for( Int i=0; i<m; ++i ) { if( !std::getline( file, line ) ) RuntimeError("Could not get entry (",i,",",j,")"); std::stringstream lineStream( line ); if( !(lineStream >> realPart) ) RuntimeError ("Could not extract real part of entry (",i,",",j,")"); A.SetRealPart( i, j, realPart ); if( isComplex ) { if( !(lineStream >> imagPart) ) RuntimeError ("Could not extract imag part of entry (",i,",",j,")"); A.SetImagPart( i, j, imagPart ); } } } }
inline void DynamicCastCheck( T* A ) { if( A == nullptr ) RuntimeError("Dynamic cast failed"); }
ImageConfigHelper::ImageConfigHelper(const ConfigParameters& config) : m_dataFormat(CHW) { std::vector<std::string> featureNames = GetSectionsWithParameter(config, "width"); std::vector<std::string> labelNames = GetSectionsWithParameter(config, "labelDim"); // REVIEW alexeyk: currently support only one feature and label section. if (featureNames.size() != 1 || labelNames.size() != 1) { RuntimeError( "ImageReader currently supports a single feature and label stream. '%d' features , '%d' labels found.", static_cast<int>(featureNames.size()), static_cast<int>(labelNames.size())); } ConfigParameters featureSection = config(featureNames[0]); size_t w = featureSection("width"); size_t h = featureSection("height"); size_t c = featureSection("channels"); std::string mbFmt = featureSection("mbFormat", "nchw"); if (AreEqualIgnoreCase(mbFmt, "nhwc") || AreEqualIgnoreCase(mbFmt, "legacy")) { m_dataFormat = HWC; } else if (!AreEqualIgnoreCase(mbFmt, "nchw") || AreEqualIgnoreCase(mbFmt, "cudnn")) { RuntimeError("ImageReader does not support the sample format '%s', only 'nchw' and 'nhwc' are supported.", mbFmt.c_str()); } auto features = std::make_shared<StreamDescription>(); features->m_id = 0; features->m_name = msra::strfun::utf16(featureSection.ConfigName()); features->m_sampleLayout = std::make_shared<TensorShape>(ImageDimensions(w, h, c).AsTensorShape(m_dataFormat)); m_streams.push_back(features); ConfigParameters label = config(labelNames[0]); size_t labelDimension = label("labelDim"); auto labelSection = std::make_shared<StreamDescription>(); labelSection->m_id = 1; labelSection->m_name = msra::strfun::utf16(label.ConfigName()); labelSection->m_sampleLayout = std::make_shared<TensorShape>(labelDimension); m_streams.push_back(labelSection); m_mapPath = config(L"file"); std::string rand = config(L"randomize", "auto"); if (AreEqualIgnoreCase(rand, "auto")) { m_randomize = true; } else if (AreEqualIgnoreCase(rand, "none")) { m_randomize = false; } else { RuntimeError("'randomize' parameter must be set to 'auto' or 'none'"); } // Identify precision string precision = config.Find("precision", "float"); if (AreEqualIgnoreCase(precision, "float")) { features->m_elementType = ElementType::tfloat; labelSection->m_elementType = ElementType::tfloat; } else if (AreEqualIgnoreCase(precision, "double")) { features->m_elementType = ElementType::tdouble; labelSection->m_elementType = ElementType::tdouble; } else { RuntimeError("Not supported precision '%s'. Expected 'double' or 'float'.", precision.c_str()); } m_cpuThreadCount = config(L"numCPUThreads", 0); }
QString SystemInfo::getProcessNameByPid(qint64 pid) { QString processName; #if defined(Q_OS_OSX) // Mac OS X // From: // http://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/io/qlockfile_unix.cpp errno = 0; char name[1024] = {0}; int retval = proc_name(pid, name, sizeof(name) / sizeof(char)); if (retval > 0) { processName = QFile::decodeName(name); } else if ((retval == 0) && (errno == static_cast<int>(std::errc::no_such_process))) { return QString(); // process not running } else { throw RuntimeError( __FILE__, __LINE__, QString(tr("proc_name() failed with error %1.")).arg(errno)); } #elif defined(Q_OS_FREEBSD) char exePath[64]; char buf[PATH_MAX + 1]; sprintf(exePath, "/proc/%lld/file", pid); size_t len = (size_t)readlink(exePath, buf, sizeof(buf)); if (len >= sizeof(buf)) { return QString(); // process not running } buf[len] = 0; processName = QFileInfo(QFile::decodeName(buf)).fileName(); #elif defined(Q_OS_LINUX) // From: // http://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/io/qlockfile_unix.cpp if (!FilePath("/proc/version").isExistingFile()) { throw RuntimeError(__FILE__, __LINE__, tr("Could not find the file \"/proc/version\".")); } char exePath[64]; char buf[PATH_MAX + 1]; sprintf(exePath, "/proc/%lld/exe", pid); size_t len = (size_t)readlink(exePath, buf, sizeof(buf)); if (len >= sizeof(buf)) { return QString(); // process not running } buf[len] = 0; processName = QFileInfo(QFile::decodeName(buf)).fileName(); // If the executable does no longer exist, the string " (deleted)" is added to // the end of the symlink, so we need to remove that to get the naked process // name. if (processName.endsWith(" (deleted)")) processName.chop(strlen(" (deleted)")); #elif defined(Q_OS_WIN32) || defined(Q_OS_WIN64) // Windows // Originally from: // http://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/io/qlockfile_win.cpp // But then saw this article: // https://blogs.msdn.microsoft.com/oldnewthing/20150716-00/?p=45131/ And // therefore switched from GetModuleFileNameExW() to // QueryFullProcessImageNameW() HANDLE hProcess = OpenProcess( PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ, FALSE, DWORD(pid)); if ((!hProcess) && (GetLastError() == ERROR_INVALID_PARAMETER)) { return QString(); // process not running } else if (!hProcess) { throw RuntimeError( __FILE__, __LINE__, QString(tr("OpenProcess() failed with error %1.")).arg(GetLastError())); } wchar_t buf[MAX_PATH]; DWORD length = MAX_PATH; BOOL success = QueryFullProcessImageNameW(hProcess, 0, buf, &length); CloseHandle(hProcess); if ((!success) || (!length)) { throw RuntimeError( __FILE__, __LINE__, QString(tr("QueryFullProcessImageNameW() failed with error %1.")) .arg(GetLastError())); } processName = QString::fromWCharArray(buf, length); int i = processName.lastIndexOf(QLatin1Char('\\')); if (i >= 0) processName.remove(0, i + 1); i = processName.lastIndexOf(QLatin1Char('.')); if (i >= 0) processName.truncate(i); #else #error "Unknown operating system!" #endif // check if the process name is not empty if (processName.isEmpty()) { throw RuntimeError( __FILE__, __LINE__, tr("Could not determine the process name of another process.")); } return processName; }
void CNTKEvalExtended<ElemType>::ForwardPassT(const std::vector<ValueBuffer<ElemType, ValueContainer> >& inputs, std::vector<ValueBuffer<ElemType, ValueContainer> >& outputs, bool resetRNN) { if (!m_started) RuntimeError("ForwardPass() called before StartForwardEvaluation()"); if (inputs.size() != (size_t)std::distance(m_inputMatrices.begin(), m_inputMatrices.end())) RuntimeError("Expected %d inputs, but got %d.", (int)std::distance(m_inputMatrices.begin(), m_inputMatrices.end()), (int)inputs.size()); if (outputs.size() != m_outputNodes.size()) RuntimeError("Expected %d outputs, but got %d.", (int)m_outputNodes.size(), (int)outputs.size()); size_t i = 0; for (auto& inputNode : m_inputNodes) { // const cast: The matrix class takes this over without copying and could theoretically change the contents, // though it doesn't in this case. auto& buffer = const_cast<ValueBuffer<ElemType, ValueContainer>&>(inputs[i]); auto matrix = dynamic_pointer_cast<Matrix<ElemType>>(inputNode->ValuePtr()); auto type = matrix->GetMatrixType(); size_t numRows = inputNode->GetSampleLayout().GetNumElements(); if (buffer.m_buffer.data() == nullptr) RuntimeError("Input %ls: Buffer is not allocated.", m_inputNodes[i]->GetName().c_str()); if (type == MatrixType::DENSE) { if (buffer.m_buffer.size() % numRows != 0) RuntimeError("Input %ls: Expected input data to be a multiple of %" PRIu64 ", but it is %" PRIu64 ".", m_inputNodes[i]->GetName().c_str(), numRows, buffer.m_buffer.size()); if (buffer.m_buffer.size() == 0) RuntimeError("Input %ls: Expected at least one element.", m_inputNodes[i]->GetName().c_str()); } else if (type == MatrixType::SPARSE) { if (buffer.m_colIndices.data() == nullptr) RuntimeError("Input %ls: Due to sparse input format, expected colIndices array, but was nullptr.", m_inputNodes[i]->GetName().c_str()); if (buffer.m_indices.data() == nullptr) RuntimeError("Input %ls: Due to sparse input format, expected Indices array, but was nullptr.", m_inputNodes[i]->GetName().c_str()); if (buffer.m_colIndices.size() < 2) RuntimeError("Input %ls: Expected at least one element (2 entries in colIndices array).", m_inputNodes[i]->GetName().c_str()); if (buffer.m_colIndices[0] != 0) RuntimeError("Input %ls: First element of column indices must be 0", m_inputNodes[i]->GetName().c_str()); if (buffer.m_colIndices[buffer.m_colIndices.size() - 1] != buffer.m_indices.size()) RuntimeError("Input %ls: Last element of column indices must be equal to the size of indices (%ld), but was %d", m_inputNodes[i]->GetName().c_str(), buffer.m_indices.size(), buffer.m_colIndices[buffer.m_colIndices.size() - 1]); } int numCols = type == MatrixType::DENSE ? buffer.m_buffer.size() / numRows : buffer.m_colIndices.size() - 1; if (numCols < 1) RuntimeError("Input: the number of column must be greater than or equal to 1."); inputNode->GetMBLayout()->Init(1, numCols); // SentinelValueIndicatingUnspecifedSequenceBeginIdx is used to specify the lower bound of look-back step of recurrent nodes inputNode->GetMBLayout()->AddSequence(0, 0, resetRNN ? 0 : SentinelValueIndicatingUnspecifedSequenceBeginIdx, numCols); if (type == MatrixType::DENSE) matrix->SetValue(numRows, numCols, matrix->GetDeviceId(), buffer.m_buffer.data(), matrixFlagNormal); else if (type == MatrixType::SPARSE) { // In the sparse case the m_data layout is identical to CUDA's CSC layout // (see http://docs.nvidia.com/cuda/cusparse/#compressed-sparse-column-format-csc). matrix->SetMatrixFromCSCFormat(buffer.m_colIndices.data(), buffer.m_indices.data(), buffer.m_buffer.data(), buffer.m_buffer.size(), numRows, numCols); } ++i; } ComputationNetwork::BumpEvalTimeStamp(m_inputNodes); this->m_net->ForwardProp(m_outputNodes); for (size_t i2 = 0; i2 < m_outputNodes.size(); ++i2) { auto node = m_outputNodes[i2]; shared_ptr<Matrix<ElemType>> outputMatrix = dynamic_pointer_cast<Matrix<ElemType>>(node->ValuePtr()); auto pMBLayout = node->GetMBLayout(); if (!pMBLayout) { pMBLayout = make_shared<MBLayout>(); pMBLayout->InitAsFrameMode(1); // treat this as if we have one single sample } const auto& seq = pMBLayout->GetAllSequences(); if (seq.size() != 1) RuntimeError("Only 1 output sequence supported by this API"); ValueContainer<ElemType>& vec = outputs[i2].m_buffer; size_t numElements = outputMatrix->GetNumElements(); if (vec.capacity() < numElements) { // Bad luck - we can't reallocate memory of an external object at this point. RuntimeError("Not enough space in output buffer for output '%ls'.", node->GetName().c_str()); } vec.resize(numElements); ElemType* data = const_cast<ElemType*>(vec.data()); outputMatrix->CopyToArray(data, numElements); } }
// Creates chunk descriptions based on chunks of underlying deserializers. void Bundler::CreateChunkDescriptions() { auto chunks = m_driver->GetChunkDescriptions(); if (chunks.size() < 1) { RuntimeError("Driving deserializer should at least provide one chunk."); } m_chunks.reserve(chunks.size()); // If there is not cleaning required simply build chunks based on the chunk descriptions of the primary deserializer. if (!m_cleanse) { for (const auto& c : chunks) { auto cd = std::make_shared<BundlerChunkDescription>(); cd->m_numberOfSamples = c->m_numberOfSamples; cd->m_numberOfSequences = c->m_numberOfSequences; cd->m_id = m_chunks.size(); cd->m_original = c; m_chunks.push_back(cd); } return; } // Otherwise build bundling chunks using underlying deserializers. std::vector<SequenceDescription> sequenceDescriptions; sequenceDescriptions.reserve(chunks.front()->m_numberOfSequences); SequenceDescription s; for (size_t chunkIndex = 0; chunkIndex < chunks.size(); ++chunkIndex) { size_t numberOfSamples = 0; size_t numberOfSequences = 0; sequenceDescriptions.clear(); // Iterating thru all sequences and identifying whether they are valid among all deserializers. m_driver->GetSequencesForChunk(chunks[chunkIndex]->m_id, sequenceDescriptions); std::set<size_t> invalid; for (size_t sequenceIndex = 0; sequenceIndex < sequenceDescriptions.size(); ++sequenceIndex) { auto sequence = sequenceDescriptions[sequenceIndex]; bool isValid = true; for (size_t deserializerIndex = 1; deserializerIndex < m_deserializers.size(); ++deserializerIndex) { m_deserializers[deserializerIndex]->GetSequenceDescriptionByKey(sequenceDescriptions[sequenceIndex].m_key, s); if (!s.m_isValid) { isValid = false; invalid.insert(sequenceIndex); break; } } if (isValid) { numberOfSamples += sequence.m_numberOfSamples; numberOfSequences++; } } // Build a chunk for valid sequences. if (numberOfSamples > 0) { auto cd = std::make_shared<BundlerChunkDescription>(); cd->m_numberOfSamples = numberOfSamples; cd->m_numberOfSequences = numberOfSequences; cd->m_id = m_chunks.size(); cd->m_original = chunks[chunkIndex]; m_chunks.push_back(cd); cd->m_invalid = std::move(invalid); } } }
HessenbergSchurInfo DoubleShift ( Matrix<Real>& H, Matrix<Complex<Real>>& w, Matrix<Real>& Z, const HessenbergSchurCtrl& ctrl ) { EL_DEBUG_CSE const Real realZero(0); const Int maxIter=30; // Cf. LAPACK for these somewhat arbitrary constants const Real exceptScale0=Real(3)/Real(4), exceptScale1=Real(-4375)/Real(10000); const Int n = H.Height(); const Int nZ = Z.Height(); Int winBeg = ( ctrl.winBeg==END ? n : ctrl.winBeg ); Int winEnd = ( ctrl.winEnd==END ? n : ctrl.winEnd ); const Int windowSize = winEnd - winBeg; HessenbergSchurInfo info; w.Resize( n, 1 ); if( windowSize == 0 ) { return info; } if( windowSize == 1 ) { w(winBeg) = H(winBeg,winBeg); return info; } // Follow LAPACK's suit and clear the two diagonals below the subdiagonal for( Int j=winBeg; j<winEnd-3; ++j ) { H(j+2,j) = realZero; H(j+3,j) = realZero; } if( winBeg <= winEnd-3 ) H(winEnd-1,winEnd-3) = realZero; // Attempt to converge the eigenvalues one or two at a time auto ctrlSweep( ctrl ); while( winBeg < winEnd ) { Int iterBeg = winBeg; Int iter; for( iter=0; iter<maxIter; ++iter ) { auto winInd = IR(iterBeg,winEnd); iterBeg += DetectSmallSubdiagonal( H(winInd,winInd) ); if( iterBeg > winBeg ) { H(iterBeg,iterBeg-1) = realZero; } if( iterBeg == winEnd-1 ) { w(iterBeg) = H(iterBeg,iterBeg); --winEnd; break; } else if( iterBeg == winEnd-2 ) { Real c, s; schur::TwoByTwo ( H(winEnd-2,winEnd-2), H(winEnd-2,winEnd-1), H(winEnd-1,winEnd-2), H(winEnd-1,winEnd-1), w(iterBeg), w(iterBeg+1), c, s ); if( ctrl.fullTriangle ) { if( n > winEnd ) blas::Rot ( n-winEnd, &H(winEnd-2,winEnd), H.LDim(), &H(winEnd-1,winEnd), H.LDim(), c, s ); blas::Rot ( winEnd-2, &H(0,winEnd-2), 1, &H(0,winEnd-1), 1, c, s ); } if( ctrl.wantSchurVecs ) { blas::Rot ( nZ, &Z(0,winEnd-2), 1, &Z(0,winEnd-1), 1, c, s ); } winEnd -= 2; break; } // Pick either the Francis shifts or exceptional shifts Real eta00, eta01, eta10, eta11; if( iter == maxIter/3 ) { const Real scale = Abs(H(iterBeg+1,iterBeg)) + Abs(H(iterBeg+2,iterBeg+1)); eta00 = exceptScale0*scale + H(iterBeg,iterBeg); eta01 = exceptScale1*scale; eta10 = scale; eta11 = eta00; } else if( iter == 2*maxIter/3 ) { const Real scale = Abs(H(winEnd-1,winEnd-2)) + Abs(H(winEnd-2,winEnd-3)); eta00 = exceptScale0*scale + H(winEnd-1,winEnd-1); eta01 = exceptScale1*scale; eta10 = scale; eta11 = eta00; } else { eta00 = H(winEnd-2,winEnd-2); eta01 = H(winEnd-2,winEnd-1); eta10 = H(winEnd-1,winEnd-2); eta11 = H(winEnd-1,winEnd-1); } Complex<Real> shift0, shift1; double_shift::PrepareShifts ( eta00, eta01, eta10, eta11, shift0, shift1 ); ctrlSweep.winBeg = iterBeg; ctrlSweep.winEnd = winEnd; double_shift::SweepOpt( H, shift0, shift1, Z, ctrlSweep ); ++info.numIterations; } if( iter == maxIter ) { if( ctrl.demandConverged ) RuntimeError("QR iteration did not converge"); else break; } } if( ctrl.progress ) Output(info.numIterations," iterations"); info.numUnconverged = winEnd-winBeg; return info; }
SequenceDataPtr TransposeTransformer::TypedTranspose<TElementTo>::Apply(ImageSequenceData* inputSequence) { auto shape = m_parent->m_inputStream.m_sampleLayout; if (shape.IsUnknown()) // Taking the shape from the sequence. { shape = inputSequence->m_sampleShape; } if (shape.IsUnknown()) RuntimeError("Unknown shape of the sample in stream '%ls'.", m_parent->m_inputStream.m_name.c_str()); assert(inputSequence->m_numberOfSamples == 1); size_t count = shape.TotalSize(); ImageDimensions dimensions(TensorShape(shape.Dimensions()), ImageLayoutKind::HWC); size_t rowCount = dimensions.m_height * dimensions.m_width; size_t channelCount = dimensions.m_numChannels; auto dims = dimensions.AsTensorShape(CHW).GetDims(); NDShape resultShape(std::vector<size_t>(dims.begin(), dims.end())); auto result = std::make_shared<DenseSequenceWithBuffer<TElementTo>>(m_memBuffers, count, resultShape); result->m_key = inputSequence->m_key; auto dst = result->GetBuffer(); if (channelCount == 3) // Unrolling for BGR, the most common case. { size_t nRows = inputSequence->m_image.rows; size_t nCols = inputSequence->m_image.cols; TElementTo* b = dst; TElementTo* g = dst + rowCount; TElementTo* r = dst + 2 * rowCount; for (size_t i = 0; i < nRows; ++i) { auto* x = inputSequence->m_image.ptr<TElementFrom>((int)i); for (size_t j = 0; j < nCols; ++j) { auto row = j * 3; *b++ = static_cast<TElementTo>(x[row]); *g++ = static_cast<TElementTo>(x[row + 1]); *r++ = static_cast<TElementTo>(x[row + 2]); } } } else { auto src = reinterpret_cast<const TElementFrom*>(inputSequence->GetDataBuffer()); for (size_t irow = 0; irow < rowCount; irow++) { for (size_t icol = 0; icol < channelCount; icol++) { dst[icol * rowCount + irow] = static_cast<TElementTo>(src[irow * channelCount + icol]); } } } result->m_numberOfSamples = inputSequence->m_numberOfSamples; return result; }
const char *Object::getClass() { throw RuntimeError( "Object::getClass: virtual function undefined for class" ); }
void ElementaryStreamDescriptorBox::parseBox(BitStream& bitstr) { parseFullBoxHeader(bitstr); ////////////////////////////////////////////// // Fill in struct ES_Descriptor // ////////////////////////////////////////////// mES_Descriptor.ES_DescrTag = bitstr.read8Bits(); if (mES_Descriptor.ES_DescrTag != 3) // ES_DescrTag { throw RuntimeError("ElementaryStreamDescritorBox ES_Descriptor.ES_DescrTag not valid"); } /* Expandable class... need to find out size based on (from ISO/IEC 14496-1) * int sizeOfInstance = 0; * bit(1) nextByte; * bit(7) sizeOfInstance; * while(nextByte) { * bit(1) nextByte; * bit(7) sizeByte; * sizeOfInstance = sizeOfInstance<<7 | sizeByte; } */ std::uint8_t readByte = 0; std::uint32_t size = 0; do { readByte = bitstr.read8Bits(); std::uint8_t sizeByte = (readByte & 0x7F); size = (size << 7) | sizeByte; } while (readByte & 0x80); mES_Descriptor.size = size; mES_Descriptor.ES_ID = bitstr.read16Bits(); mES_Descriptor.flags = bitstr.read8Bits(); if (mES_Descriptor.flags & 0x80) // streamDependenceFlag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E) { mES_Descriptor.dependsOn_ES_ID = bitstr.read16Bits(); } if (mES_Descriptor.flags & 0x40) // URL_Flag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E) { mES_Descriptor.URLlength = bitstr.read8Bits(); if (mES_Descriptor.URLlength) { bitstr.readStringWithLen(mES_Descriptor.URLstring, mES_Descriptor.URLlength); } } if (mES_Descriptor.flags & 0x20) // OCRstreamFlag as defined in 7.2.6.5.1 of ISO/IEC 14486-1:2010(E) { mES_Descriptor.OCR_ES_Id = bitstr.read16Bits(); } ////////////////////////////////////////////////////////////////// // Fill in struct ES_Descriptor.DecoderConfigDescriptor // ////////////////////////////////////////////////////////////////// mES_Descriptor.decConfigDescr.DecoderConfigDescrTag = bitstr.read8Bits(); if (mES_Descriptor.decConfigDescr.DecoderConfigDescrTag != 4) // DecoderConfigDescrTag { throw RuntimeError("ElementaryStreamDescritorBox DecoderConfigDescriptor.DecoderConfigDescrTag not valid"); } readByte = 0; size = 0; do { readByte = bitstr.read8Bits(); std::uint8_t sizeByte = (readByte & 0x7f); size = (size << 7) | sizeByte; } while (readByte & 0x80); mES_Descriptor.decConfigDescr.size = size; mES_Descriptor.decConfigDescr.objectTypeIndication = bitstr.read8Bits(); mES_Descriptor.decConfigDescr.streamType = (bitstr.read8Bits() >> 2); mES_Descriptor.decConfigDescr.bufferSizeDB = bitstr.read24Bits(); mES_Descriptor.decConfigDescr.maxBitrate = bitstr.read32Bits(); mES_Descriptor.decConfigDescr.avgBitrate = bitstr.read32Bits(); ///////////////////////////////////////////////////////////////////////////////////// // Fill in struct ES_Descriptor.DecoderConfigDescriptor.DecoderSpecificInfo // ///////////////////////////////////////////////////////////////////////////////////// while (bitstr.numBytesLeft()) // DecoderSpecificInfo is optional. { std::uint8_t tag = bitstr.read8Bits(); readByte = 0; size = 0; do { readByte = bitstr.read8Bits(); std::uint8_t sizeByte = (readByte & 0x7f); size = (size << 7) | sizeByte; } while (readByte & 0x80); DecoderSpecificInfo decSpecificInfo; decSpecificInfo.DecSpecificInfoTag = tag; decSpecificInfo.size = size; bitstr.read8BitsArray(decSpecificInfo.DecSpecificInfo, decSpecificInfo.size); if (tag == 5) // DecSpecificInfoTag { mES_Descriptor.decConfigDescr.decSpecificInfo = std::move(decSpecificInfo); } else { mOtherDecSpecificInfo.push_back(std::move(decSpecificInfo)); } } }
void Object::serialize( SerializeObject& so ) { throw RuntimeError( "Object::serialize: virtual function undefined for class" ); }
bool ReaderShim<ElemType>::GetMinibatch(StreamMinibatchInputs& matrices) { // TODO: verify that the set of matrix names is identical // to the set of reader input names. Warn if it's a subset, throw // if it's a superset. if (m_endOfEpoch) { return false; } // Check that all matrices have the same device id. // If not we should inject the IMemoryProvider per stream. int deviceId = matrices.begin()->second.matrix->GetDeviceId(); for (auto mx : matrices) assert(mx.second.matrix->GetDeviceId() == deviceId), UNUSED(deviceId); assert(m_prefetchTask.valid()); Minibatch minibatch = m_prefetchTask.get(); if (minibatch.m_endOfEpoch) { m_endOfEpoch = true; if (minibatch.m_data.empty()) { return false; } } // Reset stale mb layouts. // BUGBUG: This seems incorrect. (1) layouts should all be updated below, and (2) some of these layouts are the same, we are resetting them twice. for (const auto& iter : matrices) { iter.second.pMBLayout->Init(1, 0); } // a map to generate error messages when checking layout constraints. map<wstring, wstring> layoutToInputMap; if (!minibatch.m_data.empty()) { // TODO: Use alternating pinned buffer in the packer, do not copy anything, but pack into the pinned memory. // Copy returned minibatch to the matrices. for (const auto& mx : matrices) { if (m_nameToStreamId.find(mx.first) == m_nameToStreamId.end()) { string inputNames = EnumerateInputs(m_nameToStreamId); RuntimeError("Could not map input '%ls' to the reader. Reader outputs only [%s].", mx.first.c_str(), inputNames.c_str()); } size_t streamId = m_nameToStreamId[mx.first]; const auto& stream = minibatch.m_data[streamId]; m_numParallelSequences = stream->m_layout->GetNumParallelSequences(); // This assert no longer holds - different inputs have different sequence lengths, resulting in different number // of parallel samples. // assert(m_numParallelSequences == minibatch.m_data.front()->m_layout->GetNumParallelSequences()); auto& layout = mx.second.pMBLayout; if (layout->GetNumCols() == 0) { // layout is empty, copy layout info from the reader layout->CopyFrom(stream->m_layout, /*keepName*/ true); layoutToInputMap[layout->GetAxisName()] = mx.first; } else if (*layout != *stream->m_layout) // this does a deep value-level comparison { RuntimeError("Dynamic axis layout '%ls' is shared between inputs '%ls' and '%ls', but layouts generated " "from the input data are incompatible on this axis. Are you using different sequence lengths? " "Did you consider adding a DynamicAxis() to the Input nodes?", layout->GetAxisName(), layoutToInputMap[layout->GetAxisName()].c_str(), mx.first.c_str()); } size_t sampleSize = m_streams[streamId]->m_sampleLayout->GetNumElements(); auto& matrix = matrices.GetInputMatrix<ElemType>(mx.first); FillMatrixFromStream(m_streams[streamId]->m_storageType, &matrix, sampleSize, stream); } } if (!m_endOfEpoch) { // Starting the prefetch task. There is always a single async read in flight. // When the network requests a new minibatch, we wait for the current async to finish, // return the result and kick off a new one. m_prefetchTask = std::async(m_launchType, [this]() { return m_reader->ReadMinibatch(); }); } return !minibatch.m_data.empty(); }
// ============================================================================ Value* AngleControl::set_property(Value** arg_list, int count) { Value* val = arg_list[0]; Value* prop = arg_list[1]; if (prop == n_text || prop == n_caption) { const TCHAR* text = val->to_string(); caption = val->get_heap_ptr(); if (parent_rollout != NULL && parent_rollout->page != NULL) set_text(text, GetDlgItem(parent_rollout->page, control_ID +1), n_left); } else if(prop == n_diameter || prop == n_width || prop == n_height) { if(parent_rollout && parent_rollout->page) SetDiameter(val->to_int()); } else if(prop == n_degrees) { if(parent_rollout && parent_rollout->page) SetDegrees(val->to_float()); } else if(prop == n_radians) { if(parent_rollout && parent_rollout->page) SetRadians(val->to_float()); } else if (prop == n_range) { if(parent_rollout && parent_rollout->page) { Point3 p; if (is_point3(val)) p = val->to_point3(); else throw TypeError (MaxSDK::GetResourceStringAsMSTR(IDS_ANGLE_RANGE_MUST_BE_A_VECTOR), val); m_min = p.x; m_max = p.y; SetDegrees(m_degrees = p.z); } } else if(prop == n_startDegrees) { if(parent_rollout && parent_rollout->page) SetStartDegrees(val->to_float()); } else if(prop == n_startRadians) { if(parent_rollout && parent_rollout->page) SetStartRadians(val->to_float()); } else if(prop == n_dir) { if (val != n_CW && val != n_CCW) throw RuntimeError (MaxSDK::GetResourceStringAsMSTR(IDS_ANGLE_DIR_BAD_VALUE), val); if(parent_rollout && parent_rollout->page) m_dirCCW = val != n_CW; Invalidate(); } else if(prop == n_color) { if(parent_rollout && parent_rollout->page) SetColor(val); } else if(prop == n_bitmap) { if(parent_rollout && parent_rollout->page) SetBitmap(val); } else return RolloutControl::set_property(arg_list, count); return val; }
// TODO: Add the ability to set a maximum number of iterations inline BigInt FindFactor ( const BigInt& n, Int a, const PollardRhoCtrl& ctrl ) { if( a == 0 || a == -2 ) Output("WARNING: Problematic choice of Pollard rho shift"); BigInt tmp, gcd; BigInt one(1); auto xAdvance = [&]( BigInt& x ) { if( ctrl.numSteps == 1 ) { // TODO: Determine if there is a penalty to x *= x /* tmp = x; tmp *= x; tmp += a; x = tmp; x %= n; */ x *= x; x += a; x %= n; } else { PowMod( x, 2*ctrl.numSteps, n, x ); x += a; x %= n; } }; auto QAdvance = [&]( const BigInt& x, const BigInt& x2, BigInt& Q ) { tmp = x2; tmp -= x; Q *= tmp; Q %= n; }; Int gcdDelay = ctrl.gcdDelay; BigInt xi=ctrl.x0; BigInt x2i(xi); BigInt xiSave=xi, x2iSave=x2i; BigInt Qi(1); Int k=1, i=1; // it is okay for i to overflow since it is just for printing while( true ) { // Advance xi once xAdvance( xi ); // Advance x2i twice xAdvance( x2i ); xAdvance( x2i ); // Advance Qi QAdvance( xi, x2i, Qi ); if( k >= gcdDelay ) { GCD( Qi, n, gcd ); if( gcd > one ) { // NOTE: This was not suggested by Pollard's original paper if( gcd == n ) { if( gcdDelay == 1 ) { RuntimeError("(x) converged before (x mod p) at i=",i); } else { if( ctrl.progress ) Output("Backtracking at i=",i); i = Max( i-(gcdDelay+1), 0 ); gcdDelay = 1; xi = xiSave; x2i = x2iSave; } } else { if( ctrl.progress ) Output("Found factor ",gcd," at i=",i); return gcd; } } // NOTE: This was not suggested by Pollard's original paper k = 0; xiSave = xi; x2iSave = x2i; Qi = 1; } ++k; ++i; } }
size_t get_opposite_vertex(const Vector3I& f, const Vector2I& e) { if (f[0] != e[0] && f[0] != e[1]) return f[0]; if (f[1] != e[0] && f[1] != e[1]) return f[1]; if (f[2] != e[0] && f[2] != e[1]) return f[2]; throw RuntimeError("Face must be topologically degnerated!"); }
void DataWriter::InitFromConfig(const ConfigRecordType& /*config*/) { RuntimeError("Init shouldn't be called, use constructor"); // not implemented, calls the underlying class instead }
// Private work function. WingedEdge WingedEdge::Subdivide(bool linear, bool pascal, std::map<Vertex, std::vector<Vertex> > &derivations) { WingedEdge mesh; std::set<Edge> edges; for (auto face = faceList.begin(); face != faceList.end(); ++face) { /* massive assumption that there is 3 edges in our face */ Edge e1 = face -> first.E1(); Edge e2 = face -> first.E2(); Edge e3 = face -> first.E3(); /* might need to verify this doesn't pick duplicates */ Vertex v1 = e1.V1(); Vertex v2 = e1.V2(); Vertex v3 = (e2.V1() == v1 || e2.V1() == v2) ? e2.V2() : e2.V1(); /* guarantee we know what e2 is */ if (v1 == e3.V1() || v1 == e3.V2()) { Edge tmp = e3; e3 = e2; e2 = tmp; } int f1, f2, f3; f1 = getNumAdjacentFaces(e1); f2 = getNumAdjacentFaces(e2); f3 = getNumAdjacentFaces(e3); // Do not subdivide and do not incorporate non boundary faces. // This is the part the creates the pascal behavior, if(pascal && f1 == 2 && f2 == 2 && f3 == 2) { continue; } bool success = true; Vertex v4 = SubdivideEdge(face->first, e1, GetAdjacentVertex(face->first, e1, success), linear, derivations); Vertex v5 = SubdivideEdge(face->first, e2, GetAdjacentVertex(face->first, e2, success), linear, derivations); Vertex v6 = SubdivideEdge(face->first, e3, GetAdjacentVertex(face->first, e3, success), linear, derivations); // A half hearted success check. if(!success) { throw RuntimeError("WindgedEdge Error: Something is wrong with the mesh to be subdivided."); } { e1 = mesh.AddEdge(v1, v4); e2 = mesh.AddEdge(v1, v5); e3 = mesh.AddEdge(v5, v4); mesh.AddFace(e1, e2, e3); } { e1 = mesh.AddEdge(v4, v2); e2 = mesh.AddEdge(v4, v6); e3 = mesh.AddEdge(v6, v2); mesh.AddFace(e1, e2, e3); } { e1 = mesh.AddEdge(v5, v6); e2 = mesh.AddEdge(v5, v3); e3 = mesh.AddEdge(v3, v6); mesh.AddFace(e1, e2, e3); } { e1 = mesh.AddEdge(v6, v5); e2 = mesh.AddEdge(v6, v4); e3 = mesh.AddEdge(v4, v5); mesh.AddFace(e1, e2, e3); } } /* std::cout << "Subdivide info: " << std::endl; std::cout << "VertexList: " << mesh.NumVertices() << std::endl; std::cout << "EdgeList: " << mesh.NumEdges() << std::endl; std::cout << "FaceList: " << mesh.NumFaces() << std::endl; */ return mesh; }
HessenbergSchurInfo MultiBulge ( DistMatrix<F,MC,MR,BLOCK>& H, DistMatrix<Complex<Base<F>>,STAR,STAR>& w, DistMatrix<F,MC,MR,BLOCK>& Z, const HessenbergSchurCtrl& ctrl ) { DEBUG_CSE typedef Base<F> Real; const Real zero(0); const Grid& grid = H.Grid(); const Int n = H.Height(); Int winBeg = ( ctrl.winBeg==END ? n : ctrl.winBeg ); Int winEnd = ( ctrl.winEnd==END ? n : ctrl.winEnd ); const Int winSize = winEnd - winBeg; const Int blockSize = H.BlockHeight(); // TODO(poulson): Implement a more reasonable/configurable means of deciding // when to call the sequential implementation Int minMultiBulgeSize = Max( ctrl.minMultiBulgeSize, 2*blockSize ); // This maximum is meant to account for parallel overheads and needs to be // more principled (and perhaps based upon the number of workers and the // cluster characteristics) // TODO(poulson): Re-enable this //minMultiBulgeSize = Max( minMultiBulgeSize, 500 ); HessenbergSchurInfo info; w.Resize( n, 1 ); if( winSize < minMultiBulgeSize ) { return multibulge::RedundantlyHandleWindow( H, w, Z, ctrl ); } auto ctrlShifts( ctrl ); ctrlShifts.winBeg = 0; ctrlShifts.winEnd = END; ctrlShifts.fullTriangle = false; Int numIterSinceDeflation = 0; const Int numStaleIterBeforeExceptional = 5; // Cf. LAPACK's DLAQR0 for this choice const Int maxIter = Max(30,2*numStaleIterBeforeExceptional) * Max(10,winSize); Int iterBegLast=-1, winEndLast=-1; DistMatrix<F,STAR,STAR> hMainWin(grid), hSuperWin(grid); DistMatrix<Real,STAR,STAR> hSubWin(grid); while( winBeg < winEnd ) { if( info.numIterations >= maxIter ) { if( ctrl.demandConverged ) RuntimeError("MultiBulge QR iteration did not converge"); else break; } auto winInd = IR(winBeg,winEnd); // Detect an irreducible Hessenberg window, [iterBeg,winEnd) // --------------------------------------------------------- // TODO(poulson): Have the interblock chase from the previous sweep // collect the main and sub diagonal of H along the diagonal workers // and then broadcast across the "cross" communicator. util::GatherTridiagonal( H, winInd, hMainWin, hSubWin, hSuperWin ); Output("winBeg=",winBeg,", winEnd=",winEnd); Print( H, "H" ); Print( hMainWin, "hMainWin" ); Print( hSubWin, "hSubWin" ); Print( hSuperWin, "hSuperWin" ); const Int iterOffset = DetectSmallSubdiagonal ( hMainWin.Matrix(), hSubWin.Matrix(), hSuperWin.Matrix() ); const Int iterBeg = winBeg + iterOffset; const Int iterWinSize = winEnd-iterBeg; if( iterOffset > 0 ) { H.Set( iterBeg, iterBeg-1, zero ); hSubWin.Set( iterOffset-1, 0, zero ); } if( iterWinSize == 1 ) { if( ctrl.progress ) Output("One-by-one window at ",iterBeg); w.Set( iterBeg, 0, hMainWin.GetLocal(iterOffset,0) ); winEnd = iterBeg; numIterSinceDeflation = 0; continue; } else if( iterWinSize == 2 ) { if( ctrl.progress ) Output("Two-by-two window at ",iterBeg); const F eta00 = hMainWin.GetLocal(iterOffset,0); const F eta01 = hSuperWin.GetLocal(iterOffset,0); const Real eta10 = hSubWin.GetLocal(iterOffset,0); const F eta11 = hMainWin.GetLocal(iterOffset+1,0); multibulge::TwoByTwo ( H, eta00, eta01, eta10, eta11, w, Z, iterBeg, ctrl ); winEnd = iterBeg; numIterSinceDeflation = 0; continue; } else if( iterWinSize < minMultiBulgeSize ) { // The window is small enough to switch to the simple scheme if( ctrl.progress ) Output("Redundantly handling window [",iterBeg,",",winEnd,"]"); auto ctrlIter( ctrl ); ctrlIter.winBeg = iterBeg; ctrlIter.winEnd = winEnd; auto iterInfo = multibulge::RedundantlyHandleWindow( H, w, Z, ctrlIter ); info.numIterations += iterInfo.numIterations; winEnd = iterBeg; numIterSinceDeflation = 0; continue; } const Int numShiftsRec = ctrl.numShifts( n, iterWinSize ); if( ctrl.progress ) { Output("Iter. ",info.numIterations,": "); Output(" window is [",iterBeg,",",winEnd,")"); Output(" recommending ",numShiftsRec," shifts"); } // NOTE(poulson): In the case where exceptional shifts are used, the // main and subdiagonals of H in the window are currently redundantly // gathered. It could be worthwhile to pass in hMainWin and hSubWin. const Int shiftBeg = multibulge::ComputeShifts ( H, w, iterBeg, winBeg, winEnd, numShiftsRec, numIterSinceDeflation, numStaleIterBeforeExceptional, ctrlShifts ); auto shiftInd = IR(shiftBeg,winEnd); auto wShifts = w(shiftInd,ALL); // Perform a small-bulge sweep auto ctrlSweep( ctrl ); ctrlSweep.winBeg = iterBeg; ctrlSweep.winEnd = winEnd; multibulge::Sweep( H, wShifts, Z, ctrlSweep ); ++info.numIterations; if( iterBeg == iterBegLast && winEnd == winEndLast ) ++numIterSinceDeflation; iterBegLast = iterBeg; winEndLast = winEnd; } info.numUnconverged = winEnd-winBeg; return info; }
// // Generate summary report. // void ProfilerGenerateReport(const std::wstring& fileName, struct tm* timeInfo) { FILE* f = _wfopen(fileName.c_str(), L"wt"); if (f == NULL) { RuntimeError("Error: ProfilerGenerateReport: Cannot create file <%ls>.\n", fileName.c_str()); } fprintfOrDie(f, "CNTK Performance Profiler Summary Report\n\n"); char timeStr[32]; strftime(timeStr, sizeof(timeStr), "%Y/%m/%d %H:%M:%S", timeInfo); fprintfOrDie(f, "Time Stamp: %s\n\n", timeStr); fprintfOrDie(f, "Description................ ............Mean ..........StdDev .............Min .............Max ...........Count ...........Total\n\n"); for (int evtIdx = 0; evtIdx < profilerEvtMax; evtIdx++) { bool printLine = false; switch (c_fixedEvtDesc[evtIdx].eventType) { case profilerEvtTime: if (g_profilerState->fixedEvents[evtIdx].cnt > 0) { printLine = true; fprintfOrDie(f, "%-26s: ", c_fixedEvtDesc[evtIdx].eventDescription); char str[32]; double mean = TicksToSeconds(g_profilerState->fixedEvents[evtIdx].sum) / g_profilerState->fixedEvents[evtIdx].cnt; FormatTimeStr(str, sizeof(str), mean); fprintfOrDie(f, "%s ", str); double sum = TicksToSeconds(g_profilerState->fixedEvents[evtIdx].sum); double sumsq = TicksSqToSecondsSq(g_profilerState->fixedEvents[evtIdx].sumsq); double stdDev = sumsq - (pow(sum, 2.0) / g_profilerState->fixedEvents[evtIdx].cnt); if (stdDev < 0.0) stdDev = 0.0; stdDev = sqrt(stdDev / (double)g_profilerState->fixedEvents[evtIdx].cnt); FormatTimeStr(str, sizeof(str), stdDev); fprintfOrDie(f, "%s ", str); FormatTimeStr(str, sizeof(str), TicksToSeconds(g_profilerState->fixedEvents[evtIdx].min)); fprintfOrDie(f, "%s ", str); FormatTimeStr(str, sizeof(str), TicksToSeconds(g_profilerState->fixedEvents[evtIdx].max)); fprintfOrDie(f, "%s ", str); fprintfOrDie(f, "%16d ", g_profilerState->fixedEvents[evtIdx].cnt); FormatTimeStr(str, sizeof(str), TicksToSeconds(g_profilerState->fixedEvents[evtIdx].sum)); fprintfOrDie(f, "%s", str); } break; case profilerEvtThroughput: if (g_profilerState->fixedEvents[evtIdx].cnt > 0) { printLine = true; fprintfOrDie(f, "%-26s: ", c_fixedEvtDesc[evtIdx].eventDescription); char str[32]; double mean = ((double)g_profilerState->fixedEvents[evtIdx].sum / (double)g_profilerState->fixedEvents[evtIdx].cnt); FormatThroughputStr(str, sizeof(str), mean); fprintfOrDie(f, "%s ", str); double stdDev = g_profilerState->fixedEvents[evtIdx].sumsq - (pow((double)g_profilerState->fixedEvents[evtIdx].sum, 2.0) / (double)g_profilerState->fixedEvents[evtIdx].cnt); if (stdDev < 0.0) stdDev = 0.0; stdDev = sqrt(stdDev / (double)g_profilerState->fixedEvents[evtIdx].cnt); FormatThroughputStr(str, sizeof(str), stdDev); fprintfOrDie(f, "%s ", str); FormatThroughputStr(str, sizeof(str), (double)g_profilerState->fixedEvents[evtIdx].min); fprintfOrDie(f, "%s ", str); FormatThroughputStr(str, sizeof(str), (double)g_profilerState->fixedEvents[evtIdx].max); fprintfOrDie(f, "%s ", str); fprintfOrDie(f, "%16d ", g_profilerState->fixedEvents[evtIdx].cnt); FormatBytesStr(str, sizeof(str), g_profilerState->fixedEvents[evtIdx].totalBytes); fprintfOrDie(f, "%s", str); } break; case profilerEvtSeparator: printLine = true; fprintfOrDie(f, "%s", c_fixedEvtDesc[evtIdx].eventDescription); break; } if (printLine) fprintfOrDie(f, "\n"); } fclose(f); }
HessenbergSchurInfo MultiBulge ( Matrix<F>& H, Matrix<Complex<Base<F>>>& w, Matrix<F>& Z, const HessenbergSchurCtrl& ctrl ) { DEBUG_CSE typedef Base<F> Real; const Real zero(0); const Int n = H.Height(); Int winBeg = ( ctrl.winBeg==END ? n : ctrl.winBeg ); Int winEnd = ( ctrl.winEnd==END ? n : ctrl.winEnd ); const Int winSize = winEnd - winBeg; const Int minMultiBulgeSize = Max( ctrl.minMultiBulgeSize, 4 ); HessenbergSchurInfo info; if( winSize < minMultiBulgeSize ) { return Simple( H, w, Z, ctrl ); } w.Resize( n, 1 ); Matrix<F> U, W, WAccum; auto ctrlShifts( ctrl ); ctrlShifts.winBeg = 0; ctrlShifts.winEnd = END; ctrlShifts.fullTriangle = false; Int numIterSinceDeflation = 0; const Int numStaleIterBeforeExceptional = 5; // Cf. LAPACK's DLAQR0 for this choice const Int maxIter = Max(30,2*numStaleIterBeforeExceptional) * Max(10,winSize); Int iterBegLast=-1, winEndLast=-1; while( winBeg < winEnd ) { if( info.numIterations >= maxIter ) { if( ctrl.demandConverged ) RuntimeError("MultiBulge QR iteration did not converge"); else break; } auto winInd = IR(winBeg,winEnd); // Detect an irreducible Hessenberg window, [iterBeg,winEnd) // --------------------------------------------------------- const Int iterOffset = DetectSmallSubdiagonal( H(winInd,winInd) ); const Int iterBeg = winBeg + iterOffset; const Int iterWinSize = winEnd-iterBeg; if( iterOffset > 0 ) H(iterBeg,iterBeg-1) = zero; if( iterWinSize == 1 ) { w(iterBeg) = H(iterBeg,iterBeg); --winEnd; numIterSinceDeflation = 0; continue; } else if( iterWinSize == 2 ) { multibulge::TwoByTwo( H, w, Z, iterBeg, ctrl ); winEnd -= 2; numIterSinceDeflation = 0; continue; } else if( iterWinSize < minMultiBulgeSize ) { // The window is small enough to switch to the simple scheme auto ctrlSub( ctrl ); ctrlSub.winBeg = iterBeg; ctrlSub.winEnd = winEnd; Simple( H, w, Z, ctrlSub ); winEnd = iterBeg; continue; } const Int numShiftsRec = ctrl.numShifts( n, iterWinSize ); if( ctrl.progress ) { Output("Iter. ",info.numIterations,": "); Output(" window is [",iterBeg,",",winEnd,")"); Output(" recommending ",numShiftsRec," shifts"); } const Int shiftBeg = multibulge::ComputeShifts ( H, w, iterBeg, winBeg, winEnd, numShiftsRec, numIterSinceDeflation, numStaleIterBeforeExceptional, ctrlShifts ); auto shiftInd = IR(shiftBeg,winEnd); auto wShifts = w(shiftInd,ALL); // Perform a small-bulge sweep auto ctrlSweep( ctrl ); ctrlSweep.winBeg = iterBeg; ctrlSweep.winEnd = winEnd; multibulge::Sweep( H, wShifts, Z, U, W, WAccum, ctrlSweep ); ++info.numIterations; if( iterBeg == iterBegLast && winEnd == winEndLast ) ++numIterSinceDeflation; iterBegLast = iterBeg; winEndLast = winEnd; } info.numUnconverged = winEnd-winBeg; return info; }