T& CLI::GetParam(const std::string& identifier) { // Only use the alias if the parameter does not exist as given. std::string key = (GetSingleton().parameters.count(identifier) == 0 && identifier.length() == 1 && GetSingleton().aliases.count(identifier[0])) ? GetSingleton().aliases[identifier[0]] : identifier; if (GetSingleton().parameters.count(key) == 0) Log::Fatal << "Parameter --" << key << " does not exist in this program!" << std::endl; util::ParamData& d = GetSingleton().parameters[key]; // Make sure the types are correct. if (TYPENAME(T) != d.tname) Log::Fatal << "Attempted to access parameter --" << key << " as type " << TYPENAME(T) << ", but its true type is " << d.tname << "!" << std::endl; // We already know that required options have been passed, so we have a valid // value to return. Because the parameters held are sometimes different types // than what the user wants, we must pass through a utility function. typename util::ParameterType<T>::type& v = *boost::any_cast<typename util::ParameterType<T>::type>(&d.value); return util::HandleParameter<T>(v, d); }
void CLI::Add(const std::string& path, const std::string& description, const std::string& alias, bool required) { po::options_description& desc = CLI::GetSingleton().desc; // Must make use of boost syntax here. std::string progOptId = alias.length() ? path + "," + alias : path; // Add the alias, if necessary AddAlias(alias, path); // Add the option to boost program_options. desc.add_options()(progOptId.c_str(), po::value<T>(), description.c_str()); // Make sure the appropriate metadata is inserted into gmap. gmap_t& gmap = GetSingleton().globalValues; ParamData data; T tmp = T(); data.desc = description; data.name = path; data.tname = TYPENAME(T); data.value = boost::any(tmp); data.wasPassed = false; gmap[path] = data; // If the option is required, add it to the required options list. if (required) GetSingleton().requiredOptions.push_front(path); }
static int64_t common_seek(SDL_RWops *rw, int64_t offset, int whence) { if(!offset && whence == RW_SEEK_CUR) { return ZDATA(rw)->pos; } return SDL_SetError("Can't seek in %s stream", TYPENAME(rw)); }
void memcpytest2_sizes(size_t maxElem=0, size_t offset=0) { printSep(); printf ("test: %s<%s>\n", __func__, TYPENAME(T)); int deviceId; HIPCHECK(hipGetDevice(&deviceId)); size_t free, total; HIPCHECK(hipMemGetInfo(&free, &total)); if (maxElem == 0) { maxElem = free/sizeof(T)/5; } printf (" device#%d: hipMemGetInfo: free=%zu (%4.2fMB) total=%zu (%4.2fMB) maxSize=%6.1fMB offset=%lu\n", deviceId, free, (float)(free/1024.0/1024.0), total, (float)(total/1024.0/1024.0), maxElem*sizeof(T)/1024.0/1024.0, offset); for (size_t elem=64; elem+offset<=maxElem; elem*=2) { HIPCHECK ( hipDeviceReset() ); memcpytest2<T>(elem+offset, 0, 1, 1, 0); // unpinned host HIPCHECK ( hipDeviceReset() ); memcpytest2<T>(elem+offset, 1, 1, 1, 0); // pinned host } }
typename util::ParameterType<T>::type& CLI::GetUnmappedParam( const std::string& identifier) { std::string key = (identifier.length() == 1 && GetSingleton().aliases.count(identifier[0])) ? GetSingleton().aliases[identifier[0]] : identifier; if (GetSingleton().parameters.count(key) == 0) Log::Fatal << "Parameter --" << key << " does not exist in this program!" << std::endl; util::ParamData& d = GetSingleton().parameters[key]; // Make sure the types are correct. if (TYPENAME(T) != d.tname) Log::Fatal << "Attempted to access parameter --" << key << " as type " << TYPENAME(T) << ", but its true type is " << d.tname << "!" << std::endl; return *boost::any_cast<typename util::ParameterType<T>::type>(&d.value); }
/** * Construct an Option object. When constructed, it will register * itself with CLI. * * @param defaultValue Default value this parameter will be initialized to * (for flags, this should be false, for instance). * @param identifier The name of the option (no dashes in front; for --help, * we would pass "help"). * @param description A short string describing the option. * @param alias Short name of the parameter. "" for no alias. * @param cppName Name of the C++ type of this parameter (i.e. "int"). * @param required Whether or not the option is required at runtime. * @param input Whether or not the option is an input option. * @param noTranspose If the parameter is a matrix and this is true, then the * matrix will not be transposed on loading. * @param testName Name of the test (used for identifiying which binding test * this option belongs to) */ TestOption(const N defaultValue, const std::string& identifier, const std::string& description, const std::string& alias, const std::string& cppName, const bool required = false, const bool input = true, const bool noTranspose = false, const std::string& testName = "") { // Create the ParamData object to give to CLI. util::ParamData data; data.desc = description; data.name = identifier; data.tname = TYPENAME(N); data.alias = alias[0]; data.wasPassed = false; data.noTranspose = noTranspose; data.required = required; data.input = input; data.loaded = false; data.cppType = cppName; data.value = boost::any(defaultValue); data.persistent = false; const std::string tname = data.tname; CLI::RestoreSettings(testName, false); // Set some function pointers that we need. CLI::GetSingleton().functionMap[tname]["GetPrintableParam"] = &GetPrintableParam<N>; CLI::GetSingleton().functionMap[tname]["GetParam"] = &GetParam<N>; CLI::GetSingleton().functionMap[tname]["GetAllocatedMemory"] = &GetAllocatedMemory<N>; CLI::GetSingleton().functionMap[tname]["DeleteAllocatedMemory"] = &DeleteAllocatedMemory<N>; CLI::Add(std::move(data)); // If this is an output option, set it as passed. if (!input) CLI::SetPassed(identifier); CLI::StoreSettings(testName); CLI::ClearSettings(); }
void multiThread_1(bool serialize, bool usePinnedHost) { printSep(); printf ("test: %s<%s> serialize=%d usePinnedHost=%d\n", __func__, TYPENAME(T), serialize, usePinnedHost); std::thread t1 (memcpytest2<T>,N, usePinnedHost,0,0,0); if (serialize) { t1.join(); } std::thread t2 (memcpytest2<T>,N, usePinnedHost,0,0,0); if (serialize) { t2.join(); } if (!serialize) { t1.join(); t2.join(); } }
int font_free_unused(DviDevice *dev) { DviFont *font, *next; int count = 0; DEBUG((DBG_FONTS, "destroying unused fonts\n")); for(font = (DviFont *)fontlist.head; font; font = next) { DviFontRef *ref; next = font->next; if(font->links) continue; count++; DEBUG((DBG_FONTS, "removing unused %s font `%s'\n", TYPENAME(font), font->fontname)); listh_remove(&fontlist, LIST(font)); if(font->in) fclose(font->in); /* get rid of subfonts (but can't use `drop_chain' here) */ for(; (ref = font->subfonts); ) { font->subfonts = ref->next; mdvi_free(ref); } /* remove this font */ font_reset_font_glyphs(dev, font, MDVI_FONTSEL_GLYPH); /* let the font destroy its private data */ if(font->finfo->freedata) font->finfo->freedata(font); /* destroy characters */ if(font->chars) mdvi_free(font->chars); mdvi_free(font->fontname); mdvi_free(font->filename); mdvi_free(font); } DEBUG((DBG_FONTS, "%d unused fonts removed\n", count)); return count; }
void memcpy2Dtest(size_t numW, size_t numH, bool usePinnedHost) { size_t width = numW * sizeof(T); size_t sizeElements = width * numH; printf("memcpy2Dtest: %s<%s> size=%lu (%6.2fMB) W: %d, H:%d, usePinnedHost: %d\n", __func__, TYPENAME(T), sizeElements, sizeElements/1024.0/1024.0, (int)numW, (int)numH, usePinnedHost); T *A_d, *B_d, *C_d; T *A_h, *B_h, *C_h; size_t pitch_A, pitch_B, pitch_C; hipChannelFormatDesc desc = hipCreateChannelDesc<T>(); HipTest::initArrays2DPitch(&A_d, &B_d, &C_d, &pitch_A, &pitch_B, &pitch_C, numW, numH); HipTest::initArraysForHost(&A_h, &B_h, &C_h, numW*numH, usePinnedHost); unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, numW*numH); HIPCHECK (hipMemcpy2D (A_d, pitch_A, A_h, width, width, numH, hipMemcpyHostToDevice) ); HIPCHECK (hipMemcpy2D (B_d, pitch_B, B_h, width, width, numH, hipMemcpyHostToDevice) ); hipLaunchKernel(HipTest::vectorADD, dim3(blocks), dim3(threadsPerBlock), 0, 0, A_d, B_d, C_d, (pitch_C/sizeof(T))*numH); HIPCHECK (hipMemcpy2D (C_h, width, C_d, pitch_C, width, numH, hipMemcpyDeviceToHost) ); HIPCHECK ( hipDeviceSynchronize() ); HipTest::checkVectorADD(A_h, B_h, C_h, numW*numH); HipTest::freeArrays (A_d, B_d, C_d, A_h, B_h, C_h, usePinnedHost); printf (" %s success\n", __func__); }
/** * Construct an Option object. When constructed, it will register * itself with CLI. * * @param defaultValue Default value this parameter will be initialized to * (for flags, this should be false, for instance). * @param identifier The name of the option (no dashes in front; for --help, * we would pass "help"). * @param description A short string describing the option. * @param alias Short name of the parameter. "" for no alias. * @param cppName Name of the C++ type of this parameter (i.e. "int"). * @param required Whether or not the option is required at runtime. * @param input Whether or not the option is an input option. * @param noTranspose If the parameter is a matrix and this is true, then the * matrix will not be transposed on loading. * @param testName Is not used and added for compatibility reasons. */ CLIOption(const N defaultValue, const std::string& identifier, const std::string& description, const std::string& alias, const std::string& cppName, const bool required = false, const bool input = true, const bool noTranspose = false, const std::string& /*testName*/ = "") { // Create the ParamData object to give to CLI. util::ParamData data; data.desc = description; data.name = identifier; data.tname = TYPENAME(N); data.alias = alias[0]; data.wasPassed = false; data.noTranspose = noTranspose; data.required = required; data.input = input; data.loaded = false; data.persistent = false; // All CLI parameters are not persistent. data.cppType = cppName; // Apply default value. if (std::is_same<typename std::remove_pointer<N>::type, typename ParameterType<typename std::remove_pointer<N>::type>::type>::value) { data.value = boost::any(defaultValue); } else { typename ParameterType<typename std::remove_pointer<N>::type>::type tmp; data.value = boost::any(std::tuple<N, decltype(tmp)>(defaultValue, tmp)); } const std::string tname = data.tname; const std::string boostName = MapParameterName< typename std::remove_pointer<N>::type>(identifier); std::string progOptId = (alias[0] != '\0') ? boostName + "," + std::string(1, alias[0]) : boostName; // Do a check to ensure that the boost name isn't already in use. const std::map<std::string, util::ParamData>& parameters = CLI::Parameters(); if (parameters.count(boostName) > 0) { // Create a fake Log::Fatal since it may not yet be initialized. // Temporarily define color code escape sequences. #ifndef _WIN32 #define BASH_RED "\033[0;31m" #define BASH_CLEAR "\033[0m" #else #define BASH_RED "" #define BASH_CLEAR "" #endif // Temporary outstream object for detecting duplicate identifiers. util::PrefixedOutStream outstr(std::cerr, BASH_RED "[FATAL] " BASH_CLEAR, false, true /* fatal */); #undef BASH_RED #undef BASH_CLEAR outstr << "Parameter --" << boostName << " (" << data.alias << ") " << "is defined multiple times with the same identifiers." << std::endl; } CLI::Add(std::move(data)); // Set some function pointers that we need. CLI::GetSingleton().functionMap[tname]["DefaultParam"] = &DefaultParam<N>; CLI::GetSingleton().functionMap[tname]["OutputParam"] = &OutputParam<N>; CLI::GetSingleton().functionMap[tname]["GetPrintableParam"] = &GetPrintableParam<N>; CLI::GetSingleton().functionMap[tname]["StringTypeParam"] = &StringTypeParam<N>; CLI::GetSingleton().functionMap[tname]["GetParam"] = &GetParam<N>; CLI::GetSingleton().functionMap[tname]["GetRawParam"] = &GetRawParam<N>; CLI::GetSingleton().functionMap[tname]["AddToPO"] = &AddToPO<N>; CLI::GetSingleton().functionMap[tname]["MapParameterName"] = &MapParameterName<N>; CLI::GetSingleton().functionMap[tname]["SetParam"] = &SetParam<N>; CLI::GetSingleton().functionMap[tname]["GetPrintableParamName"] = &GetPrintableParamName<N>; CLI::GetSingleton().functionMap[tname]["GetPrintableParamValue"] = &GetPrintableParamValue<N>; CLI::GetSingleton().functionMap[tname]["GetAllocatedMemory"] = &GetAllocatedMemory<N>; CLI::GetSingleton().functionMap[tname]["DeleteAllocatedMemory"] = &DeleteAllocatedMemory<N>; }
bool CAddition::Do(Energy* E) { ePipeline* Pipe = (ePipeline*)E; if (Pipe->Size()<2) { return false; } eElectron DataA; eElectron DataB; Pipe->Pop(&DataA); Pipe->Pop(&DataB); uint32 TypeA = DataA.EnergyType(); uint32 TypeB = DataB.EnergyType(); if(TypeA == TYPE_INT) { int64 a = DataA.Int64(); if (TypeB == TYPE_INT) { int64 b = DataB.Int64(); Pipe->PushInt(a+b); return true; }else if (TypeB == TYPE_FLOAT) { float64 f = DataB.Float64(); int64 b = (int64)f; Pipe->PushInt(a+b); return true; } }else if (TypeA == TYPE_FLOAT) { float64 a = DataA.Float64(); if (TypeB == TYPE_INT) { int64 t = DataB.Int64(); float64 b = (float64)t; Pipe->PushFloat(a+b); return true; }else if (TypeB == TYPE_FLOAT) { float64 b = DataB.Float64(); Pipe->PushFloat(a+b); return true; } } Pipe->GetLabel()=Format1024(_T("%I64ld Error: %s and %s can't make addition(+) operator!"),m_ID,TYPENAME(TypeA),TYPENAME(TypeB)); return false; }
void CLI::Add(const std::string& identifier, const std::string& description, const std::string& alias, const bool required, const bool input) { // Temporarily define color code escape sequences. #ifndef _WIN32 #define BASH_RED "\033[0;31m" #define BASH_CLEAR "\033[0m" #else #define BASH_RED "" #define BASH_CLEAR "" #endif // Temporary outstream object for detecting duplicate identifiers. util::PrefixedOutStream outstr(std::cerr, BASH_RED "[FATAL] " BASH_CLEAR, false, true /* fatal */); #undef BASH_RED #undef BASH_CLEAR // Define identifier and alias maps. gmap_t& gmap = GetSingleton().globalValues; amap_t& amap = GetSingleton().aliasValues; // If found in current map, print fatal error and terminate the program. if (gmap.count(identifier)) outstr << "Parameter --" << identifier << "(-" << alias << ") " << "is defined multiple times with same identifiers." << std::endl; if (amap.count(alias)) outstr << "Parameter --" << identifier << "(-" << alias << ") " << "is defined multiple times with same alias." << std::endl; po::options_description& desc = CLI::GetSingleton().desc; // Must make use of boost syntax here. std::string progOptId = alias.length() ? identifier + "," + alias : identifier; // Add the alias, if necessary AddAlias(alias, identifier); // Add the option to boost program_options. desc.add_options()(progOptId.c_str(), po::value<T>(), description.c_str()); // Make sure the appropriate metadata is inserted into gmap. ParamData data; T tmp = T(); data.desc = description; data.name = identifier; data.tname = TYPENAME(T); data.value = boost::any(tmp); data.wasPassed = false; gmap[identifier] = data; // If the option is required, add it to the required options list. if (required) GetSingleton().requiredOptions.push_front(identifier); // Depending on whether or not the option is input or output, add it to the // appropriate list. if (input) GetSingleton().inputOptions.push_front(identifier); else GetSingleton().outputOptions.push_front(identifier); }
void CLI::Add(const T& defaultValue, const std::string& identifier, const std::string& description, const char alias, const bool required, const bool input, const bool noTranspose) { // Temporarily define color code escape sequences. #ifndef _WIN32 #define BASH_RED "\033[0;31m" #define BASH_CLEAR "\033[0m" #else #define BASH_RED "" #define BASH_CLEAR "" #endif // Temporary outstream object for detecting duplicate identifiers. util::PrefixedOutStream outstr(std::cerr, BASH_RED "[FATAL] " BASH_CLEAR, false, true /* fatal */); #undef BASH_RED #undef BASH_CLEAR // Define identifier and alias maps. std::map<std::string, util::ParamData>& parameters = GetSingleton().parameters; std::map<char, std::string>& aliases = GetSingleton().aliases; // If found in current map, print fatal error and terminate the program. if (parameters.count(identifier)) outstr << "Parameter --" << identifier << " (-" << alias << ") " << "is defined multiple times with the same identifiers." << std::endl; if (alias != '\0' && aliases.count(alias)) outstr << "Parameter --" << identifier << " (-" << alias << ") " << "is defined multiple times with the same alias." << std::endl; // Add the parameter to the map of parameters. We must hold two boost::any // types, in case the type that boost::po receives will be different than the // type we want (like for matrices). util::ParamData data; typename util::ParameterType<T>::type tmp; T mappedTmp; data.desc = description; data.name = identifier; data.tname = TYPENAME(T); data.alias = alias; data.isFlag = (TYPENAME(T) == TYPENAME(bool)); data.noTranspose = noTranspose; data.required = required; data.input = input; data.loaded = false; data.boostName = util::MapParameterName<T>(identifier); // Apply default value. if (std::is_same<T, typename util::ParameterType<T>::type>::value) { data.value = boost::any(defaultValue); data.mappedValue = boost::any(mappedTmp); } else { data.value = boost::any(tmp); data.mappedValue = boost::any(defaultValue); } // Sanity check: ensure that the boost name is not already in use. std::map<std::string, util::ParamData>::const_iterator it = parameters.begin(); while (it != parameters.end()) { if ((*it).second.boostName == data.boostName || (*it).second.name == data.boostName) outstr << "Parameter --" << data.boostName << " (" << alias << ") " << "is defined multiple times with the same identifiers." << std::endl; ++it; } GetSingleton().parameters[identifier] = data; // Now add the parameter name to boost::program_options. po::options_description& desc = CLI::GetSingleton().desc; // Must make use of boost syntax here. std::string progOptId = (alias != '\0') ? data.boostName + "," + std::string(1, alias) : data.boostName; // Add the alias, if necessary. if (alias != '\0') GetSingleton().aliases[alias] = identifier; // Add the option to boost program_options. if (data.isFlag) desc.add_options()(progOptId.c_str(), description.c_str()); else GetSingleton().AddOption<typename util::ParameterType<T>::type>(progOptId.c_str(), description.c_str()); // If the option is required, add it to the required options list. if (required) GetSingleton().requiredOptions.push_front(identifier); // Depending on whether or not the option is input or output, add it to the // appropriate list. if (!input) GetSingleton().outputOptions.push_front(identifier); }
bool TokenSource::peekToken() { bool result = true; if(!d_inreserve) { char c; d_so.peekCharacter(c," \n"); if(c=='+') { d_type = PLUS; d_s = "+"; d_n = -999; } else if(c=='/') { d_type = DIVIDE; d_s = "/"; d_n = -999; } else if(c=='_') { d_type = PATTERN; d_s = "_"; d_n = -999; } else if(c=='*') { d_so.passCharacter(); d_so.peekCharacter(c," \n"); if(c!='*') { GBStream << "Stars must appear in pairs.\n"; DBG(); }; d_so.passCharacter(); d_type = DOUBLESTAR; d_s = "**"; d_n = -999; } else if('0'<=c && c<='9') { d_type = INTEGER; d_s = "invalid"; int n = d_so.grabInteger(); } else if(c='\"') { int dummy; d_type = STRING; d_s = getString(dummy); d_n = -999; } else if(c=='[') { d_type = LBRACKET; d_s = "["; d_n = -999; } else if(c==']') { d_type = RBRACKET; d_s = "]"; d_n = -999; } else if(c=='{') { d_type = LCURLY; d_s = "["; d_n = -999; } else if(c=='}') { d_type = RCURLY; d_s = "]"; d_n = -999; } else if(c==',') { d_type = COMMA; d_s = ","; d_n = -999; } else if(('a'<=c&&c<='z') ||('A'<=c&&c<='Z')) { int dummy; d_type = SYMBOL; d_s = getAlphaNumWord(dummy); d_n = -999; } else { GBStream << "Encounted unexpected character " << c << '\n'; GBStream << "The last token encounted has string " << d_s << " and integer " << n << " and was of type " << TYPENAME(d_type) << '\n'; DBG(); }; }; };
/** * Construct a PyOption object. When constructed, it will register itself * with CLI. The testName parameter is not used and added for compatibility * reasons. */ PyOption(const T defaultValue, const std::string& identifier, const std::string& description, const std::string& alias, const std::string& cppName, const bool required = false, const bool input = true, const bool noTranspose = false, const std::string& /*testName*/ = "") { // Create the ParamData object to give to CLI. util::ParamData data; data.desc = description; data.name = identifier; data.tname = TYPENAME(T); data.alias = alias[0]; data.wasPassed = false; data.noTranspose = noTranspose; data.required = required; data.input = input; data.loaded = false; // Only "verbose" and "copy_all_inputs" will be persistent. if (identifier == "verbose" || identifier == "copy_all_inputs") data.persistent = true; else data.persistent = false; data.cppType = cppName; // Every parameter we'll get from Python will have the correct type. data.value = boost::any(defaultValue); // Restore the parameters for this program. if (identifier != "verbose" && identifier != "copy_all_inputs") CLI::RestoreSettings(programName, false); // Set the function pointers that we'll need. All of these function // pointers will be used by both the program that generates the pyx, and // also the binding itself. (The binding itself will only use GetParam, // GetPrintableParam, and GetRawParam.) CLI::GetSingleton().functionMap[data.tname]["GetParam"] = &GetParam<T>; CLI::GetSingleton().functionMap[data.tname]["GetPrintableParam"] = &GetPrintableParam<T>; // These are used by the pyx generator. CLI::GetSingleton().functionMap[data.tname]["PrintClassDefn"] = &PrintClassDefn<T>; CLI::GetSingleton().functionMap[data.tname]["PrintDefn"] = &PrintDefn<T>; CLI::GetSingleton().functionMap[data.tname]["PrintDoc"] = &PrintDoc<T>; CLI::GetSingleton().functionMap[data.tname]["PrintOutputProcessing"] = &PrintOutputProcessing<T>; CLI::GetSingleton().functionMap[data.tname]["PrintInputProcessing"] = &PrintInputProcessing<T>; CLI::GetSingleton().functionMap[data.tname]["ImportDecl"] = &ImportDecl<T>; // Add the ParamData object, then store. This is necessary because we may // import more than one .so that uses CLI, so we have to keep the options // separate. programName is a global variable from mlpack_main.hpp. CLI::Add(std::move(data)); if (identifier != "verbose" && identifier != "copy_all_inputs") CLI::StoreSettings(programName); CLI::ClearSettings(); }
static int load_one_glyph(DviContext *dvi, DviFont *font, int code) { BITMAP *map; DviFontChar *ch; int status; #ifndef NODEBUG ch = FONTCHAR(font, code); DEBUG((DBG_GLYPHS, "loading glyph code %d in %s (at %u)\n", code, font->fontname, ch->offset)); #endif if(font->finfo->getglyph == NULL) { /* font type does not need to load glyphs (e.g. vf) */ return 0; } status = font->finfo->getglyph(&dvi->params, font, code); if(status < 0) return -1; /* get the glyph again (font->chars may have changed) */ ch = FONTCHAR(font, code); #ifndef NODEBUG map = (BITMAP *)ch->glyph.data; if(DEBUGGING(BITMAP_DATA)) { DEBUG((DBG_BITMAP_DATA, "%s: new %s bitmap for character %d:\n", font->fontname, TYPENAME(font), code)); if(MDVI_GLYPH_ISEMPTY(map)) DEBUG((DBG_BITMAP_DATA, "blank bitmap\n")); else bitmap_print(stderr, map); } #endif /* check if we have to scale it */ if(!font->finfo->scalable && font->hdpi != font->vdpi) { int hs, vs, d; /* we scale it ourselves */ d = Max(font->hdpi, font->vdpi); hs = d / font->hdpi; vs = d / font->vdpi; if(ch->width && ch->height && (hs > 1 || vs > 1)) { int h, v; DviGlyph glyph; DEBUG((DBG_FONTS, "%s: scaling glyph %d to resolution %dx%d\n", font->fontname, code, font->hdpi, font->vdpi)); h = dvi->params.hshrink; v = dvi->params.vshrink; d = dvi->params.density; dvi->params.hshrink = hs; dvi->params.vshrink = vs; dvi->params.density = 50; /* shrink it */ font->finfo->shrink0(dvi, font, ch, &glyph); /* restore parameters */ dvi->params.hshrink = h; dvi->params.vshrink = v; dvi->params.density = d; /* update glyph data */ if(!MDVI_GLYPH_ISEMPTY(ch->glyph.data)) bitmap_destroy((BITMAP *)ch->glyph.data); ch->glyph.data = glyph.data; ch->glyph.x = glyph.x; ch->glyph.y = glyph.y; ch->glyph.w = glyph.w; ch->glyph.h = glyph.h; } } font_transform_glyph(dvi->params.orientation, &ch->glyph); return 0; }
static int64_t common_size(SDL_RWops *rw) { return SDL_SetError("Can't get size of %s stream", TYPENAME(rw)); }
void memcpytest2(size_t numElements, bool usePinnedHost, bool useHostToHost, bool useDeviceToDevice, bool useMemkindDefault) { size_t sizeElements = numElements * sizeof(T); printf ("test: %s<%s> size=%lu (%6.2fMB) usePinnedHost:%d, useHostToHost:%d, useDeviceToDevice:%d, useMemkindDefault:%d\n", __func__, TYPENAME(T), sizeElements, sizeElements/1024.0/1024.0, usePinnedHost, useHostToHost, useDeviceToDevice, useMemkindDefault); T *A_d, *B_d, *C_d; T *A_h, *B_h, *C_h; HipTest::initArrays (&A_d, &B_d, &C_d, &A_h, &B_h, &C_h, numElements, usePinnedHost); unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, numElements); T *A_hh = NULL; T *B_hh = NULL; T *C_dd = NULL; if (useHostToHost) { if (usePinnedHost) { HIPCHECK ( hipHostMalloc((void**)&A_hh, sizeElements, hipHostMallocDefault) ); HIPCHECK ( hipHostMalloc((void**)&B_hh, sizeElements, hipHostMallocDefault) ); } else { A_hh = (T*)malloc(sizeElements); B_hh = (T*)malloc(sizeElements); } // Do some extra host-to-host copies here to mix things up: HIPCHECK ( hipMemcpy(A_hh, A_h, sizeElements, useMemkindDefault? hipMemcpyDefault : hipMemcpyHostToHost)); HIPCHECK ( hipMemcpy(B_hh, B_h, sizeElements, useMemkindDefault? hipMemcpyDefault : hipMemcpyHostToHost)); HIPCHECK ( hipMemcpy(A_d, A_hh, sizeElements, useMemkindDefault ? hipMemcpyDefault : hipMemcpyHostToDevice)); HIPCHECK ( hipMemcpy(B_d, B_hh, sizeElements, useMemkindDefault ? hipMemcpyDefault : hipMemcpyHostToDevice)); } else { HIPCHECK ( hipMemcpy(A_d, A_h, sizeElements, useMemkindDefault ? hipMemcpyDefault : hipMemcpyHostToDevice)); HIPCHECK ( hipMemcpy(B_d, B_h, sizeElements, useMemkindDefault ? hipMemcpyDefault : hipMemcpyHostToDevice)); } hipLaunchKernel(HipTest::vectorADD, dim3(blocks), dim3(threadsPerBlock), 0, 0, A_d, B_d, C_d, numElements); if (useDeviceToDevice) { HIPCHECK ( hipMalloc(&C_dd, sizeElements) ); // Do an extra device-to-device copies here to mix things up: HIPCHECK ( hipMemcpy(C_dd, C_d, sizeElements, useMemkindDefault? hipMemcpyDefault : hipMemcpyDeviceToDevice)); //Destroy the original C_d: HIPCHECK ( hipMemset(C_d, 0x5A, sizeElements)); HIPCHECK ( hipMemcpy(C_h, C_dd, sizeElements, useMemkindDefault? hipMemcpyDefault:hipMemcpyDeviceToHost)); } else { HIPCHECK ( hipMemcpy(C_h, C_d, sizeElements, useMemkindDefault? hipMemcpyDefault:hipMemcpyDeviceToHost)); } HIPCHECK ( hipDeviceSynchronize() ); HipTest::checkVectorADD(A_h, B_h, C_h, numElements); HipTest::freeArrays (A_d, B_d, C_d, A_h, B_h, C_h, usePinnedHost); printf (" %s success\n", __func__); }
void memcpyArraytest(size_t numW, size_t numH, bool usePinnedHost, bool usePitch=false) { size_t width = numW * sizeof(T); size_t sizeElements = width * numH; printf("memcpyArraytest: %s<%s> size=%lu (%6.2fMB) W: %d, H: %d, usePinnedHost: %d, usePitch: %d\n", __func__, TYPENAME(T), sizeElements, sizeElements/1024.0/1024.0, (int)numW, (int)numH, usePinnedHost, usePitch); hipArray *A_d, *B_d, *C_d; T *A_h, *B_h, *C_h; // 1D if ((numW >= 1) && (numH == 1)) { hipChannelFormatDesc desc = hipCreateChannelDesc<T>(); HipTest::initHIPArrays(&A_d, &B_d, &C_d, &desc, numW, 1, 0); HipTest::initArraysForHost(&A_h, &B_h, &C_h, numW*numH, usePinnedHost); unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, numW*numH); HIPCHECK (hipMemcpyToArray (A_d, 0, 0, (void *)A_h, width, hipMemcpyHostToDevice) ); HIPCHECK (hipMemcpyToArray (B_d, 0, 0, (void *)B_h, width, hipMemcpyHostToDevice) ); hipLaunchKernel(HipTest::vectorADD, dim3(blocks), dim3(threadsPerBlock), 0, 0, (T*)A_d->data, (T*)B_d->data, (T*)C_d->data, numW); HIPCHECK (hipMemcpy (C_h, C_d->data, width, hipMemcpyDeviceToHost) ); HIPCHECK ( hipDeviceSynchronize() ); HipTest::checkVectorADD(A_h, B_h, C_h, numW); } // 2D else if ((numW >= 1) && (numH >= 1)) { hipChannelFormatDesc desc = hipCreateChannelDesc<T>(); HipTest::initHIPArrays(&A_d, &B_d, &C_d, &desc, numW, numH, 0); HipTest::initArraysForHost(&A_h, &B_h, &C_h, numW*numH, usePinnedHost); unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, numW*numH); if (usePitch) { T *A_p, *B_p, *C_p; size_t pitch_A, pitch_B, pitch_C; HipTest::initArrays2DPitch(&A_p, &B_p, &C_p, &pitch_A, &pitch_B, &pitch_C, numW, numH); HIPCHECK (hipMemcpy2D (A_p, pitch_A, A_h, width, width, numH, hipMemcpyHostToDevice) ); HIPCHECK (hipMemcpy2D (B_p, pitch_B, B_h, width, width, numH, hipMemcpyHostToDevice) ); HIPCHECK (hipMemcpy2DToArray (A_d, 0, 0, (void *)A_p, pitch_A, width, numH, hipMemcpyDeviceToDevice) ); HIPCHECK (hipMemcpy2DToArray (B_d, 0, 0, (void *)B_p, pitch_B, width, numH, hipMemcpyDeviceToDevice) ); hipFree(A_p); hipFree(B_p); hipFree(C_p); } else { HIPCHECK (hipMemcpy2DToArray (A_d, 0, 0, (void *)A_h, width, width, numH, hipMemcpyHostToDevice) ); HIPCHECK (hipMemcpy2DToArray (B_d, 0, 0, (void *)B_h, width, width, numH, hipMemcpyHostToDevice) ); } hipLaunchKernel(HipTest::vectorADD, dim3(blocks), dim3(threadsPerBlock), 0, 0, (T*)A_d->data, (T*)B_d->data, (T*)C_d->data, numW*numH); HIPCHECK (hipMemcpy2D ((void*)C_h, width, (void*)C_d->data, width, width, numH, hipMemcpyDeviceToHost) ); HIPCHECK ( hipDeviceSynchronize() ); HipTest::checkVectorADD(A_h, B_h, C_h, numW*numH); } // Unknown else { HIPASSERT("Incompatible dimensions" && 0); } hipFreeArray(A_d); hipFreeArray(B_d); hipFreeArray(C_d); HipTest::freeArraysForHost(A_h, B_h, C_h, usePinnedHost); printf (" %s success\n", __func__); }