void ExecutorCommon::init(){ actuatorHandles[ActuatorType::RELOAD_CONFIG]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::reloadConfig); actuatorHandles[ActuatorType::GET_POPCORN]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::getPopcorn); actuatorHandles[ActuatorType::UNLOAD_POPCORN]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::unloadPopcorn); actuatorHandles[ActuatorType::KICK_RIGHT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::kickRight); actuatorHandles[ActuatorType::KICK_LEFT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::kickLeft); actuatorHandles[ActuatorType::UNKICK_RIGHT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::unKickRight); actuatorHandles[ActuatorType::UNKICK_LEFT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::unKickLeft); actuatorHandles[ActuatorType::GET_OBJECT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::getObject); actuatorHandles[ActuatorType::UNLOAD_OBJECT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::unloadObject); actuatorHandles[ActuatorType::RELOAD_CONFIG]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::reloadConfig); actuatorHandles[ActuatorType::GET_OBJECT_STOP]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::getObjectStop); actuatorHandles[ActuatorType::START_BRXON]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::startBrxon); actuatorHandles[ActuatorType::STOP_BRXON]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::stopBrxon); actuatorHandles[ActuatorType::START_BEACON]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::startBeacon); actuatorHandles[ActuatorType::STOP_BEACON]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::stopBeacon); actuatorHandles[ActuatorType::LEAVE_CARPET]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::leaveCarpet); actuatorHandles[ActuatorType::CARPET_LEAVE]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::carpetLeave); actuatorHandles[ActuatorType::CARPET_POSITION_1]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::carpetPosition1); actuatorHandles[ActuatorType::CARPET_POSITION_2]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::carpetPosition2); actuatorHandles[ActuatorType::CARPET_POSITION_OPEN]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::carpetPositionOpen); actuatorHandles[ActuatorType::CARPET_POSITION_CLOSE]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::carpetPositionClose); actuatorHandles[ActuatorType::CALLBACK_GET_LEFT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::callbackGetLeft); actuatorHandles[ActuatorType::CALLBACK_GET_RIGHT]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::callbackGetRight); actuatorHandles[ActuatorType::START_DETECTION]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::startDetection); actuatorHandles[ActuatorType::STOP_DETECTION]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::stopDetection); //enemy detecotr actuatorHandles[ActuatorType::SENSOR_CALLBACK]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::sensorCommand); actuatorHandles[ActuatorType::BRKON_CALLBACK]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::brkonCommand); actuatorHandles[ActuatorType::BEACON_MALI_CALLBACK]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::beaconMaliCommand); actuatorHandles[ActuatorType::BEACON_VELIKI_CALLBACK]=static_cast<ActuatorCommandHandle>(&ExecutorCommon::beaconVelikiCommand); //added for new "Srednji mehanizam" suscribeToSensore(); suscribe(); mapping(); }
/* Convert atom to name */ static int unatom(struct inode *atable, atom_t atom, char *name, unsigned size) { if(DEBUG_MODE_K==1) { printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__); } struct sb *sb = tux_sb(atable->i_sb); struct buffer_head *buffer; int err; loff_t where = unatom_dict_read(atable, atom); if (where < 0) { err = where; goto error; } buffer = blockread(mapping(atable), where >> sb->blockbits); if (!buffer) { err = -EIO; goto error; } tux_dirent *entry = bufdata(buffer) + (where & sb->blockmask); if (entry_atom(entry) != atom) { tux3_fs_error(sb, "atom %x reverse entry broken", atom); err = -EIO; goto error_blockput; } unsigned len = entry->name_len; if (size) { if (len > size) { err = -ERANGE; goto error_blockput; } memcpy(name, entry->name, len); } blockput(buffer); return len; error_blockput: blockput(buffer); error: return err; }
void InputMap::loadDefaults() { QString profileName; QSettings settings; QString plugin; QVariant value; QString input; QString key; /* Editor universe */ key = QString("/inputmap/editoruniverse/"); value = settings.value(key); if (value.isValid() == true) setEditorUniverse(value.toInt()); for (quint32 i = 0; i < m_universes; i++) { /* Plugin name */ key = QString("/inputmap/universe%2/plugin/").arg(i); plugin = settings.value(key).toString(); /* Plugin input */ key = QString("/inputmap/universe%2/input/").arg(i); input = settings.value(key).toString(); /* Input profile */ key = QString("/inputmap/universe%2/profile/").arg(i); profileName = settings.value(key).toString(); /* Do the mapping */ if (plugin.length() > 0 && input.length() > 0) { /* Check that the same plugin & input are not mapped to more than one universe at a time. */ quint32 m = mapping(plugin, input.toInt()); if (m == InputMap::invalidUniverse() || m == i) { setPatch(i, plugin, input.toInt(), profileName); } } } }
void BVH4BuilderTopLevel::split_sequential(BuildRecord& current, BuildRecord& leftChild, BuildRecord& rightChild) { /* calculate binning function */ Mapping2<16> mapping(current.bounds); /* binning of centroids */ Binner2<16> binner; binner.bin(&refs[0],current.begin,current.end,mapping); /* find best split */ Split2 split; binner.best(split,mapping); /* if we cannot find a valid split, enforce an arbitrary split */ if (unlikely(split.pos == -1)) split_fallback2(&refs[0],current,leftChild,rightChild); /* partitioning of items */ else binner.partition(&refs[0], current.begin, current.end, split, mapping, leftChild, rightChild); }
double mapping_withlintrans(double x0, double y0, double *x1, double *y1, double xcen, double ycen, double b11, double b12, double b21, double b22, int n, double a[]) { double xr,yr; double det; xr=xcen+b11*(x0-xcen)+b12*(y0-ycen); yr=ycen+b21*(x0-xcen)+b22*(y0-ycen); det=b11*b22-b21*b12; /* caution !! */ /* b matrix is celestial => telescope */ /* ie. det<1 for airmass */ return det*mapping(xr,yr,x1,y1,xcen,ycen,n,a); }
TEST(MeshLib, CoordinatesMappingLocalLowerDimQuadXYZ) { auto ele = TestQuad4::createXYZ(); MeshLib::ElementCoordinatesMappingLocal mapping(*ele, MeshLib::CoordinateSystem(*ele)); auto matR(mapping.getRotationMatrixToGlobal()); //debugOutput(ele, mapping); // results when using GeoLib::ComputeRotationMatrixToXY() double exp_R[3*3] = { 1, 0, 0, 0, 0.70710678118654757, -0.70710678118654757, 0, 0.70710678118654757, 0.70710678118654757}; const double eps(std::numeric_limits<double>::epsilon()); ASSERT_ARRAY_NEAR(exp_R, matR.data(), matR.size(), eps); CHECK_COORDS(ele,mapping); for (std::size_t n = 0; n < ele->getNumberOfNodes(); ++n) delete ele->getNode(n); }
boost::optional<mapped_region_ptr> mapped_memory_cache::find(std::string const& uri, bool update_cache) { #ifdef MAPNIK_THREADSAFE std::lock_guard<std::mutex> lock(mutex_); #endif using iterator_type = std::unordered_map<std::string, mapped_region_ptr>::const_iterator; boost::optional<mapped_region_ptr> result; iterator_type itr = cache_.find(uri); if (itr != cache_.end()) { result.reset(itr->second); return result; } if (mapnik::util::exists(uri)) { try { boost::interprocess::file_mapping mapping(uri.c_str(),boost::interprocess::read_only); mapped_region_ptr region(std::make_shared<boost::interprocess::mapped_region>(mapping,boost::interprocess::read_only)); result.reset(region); if (update_cache) { cache_.emplace(uri, *result); } return result; } catch (std::exception const& ex) { MAPNIK_LOG_ERROR(mapped_memory_cache) << "Error loading mapped memory file: '" << uri << "' (" << ex.what() << ")"; } } /* else { MAPNIK_LOG_WARN(mapped_memory_cache) << "Memory region does not exist file: " << uri; } */ return result; }
// This function will get all the mappings which have the same commandlistId's (substates) into aMappingArray void CSsmCommandListResourceReaderImpl::CResourcePool::UpdateMappingArrayL(TInt aCommandListId, RArray<TMapping>& aMappingArray) const { aMappingArray.Reset(); TMapping mapping(aCommandListId, 0, NULL); const TInt mappingCount = iMappings.Count(); TInt mappingIndex = iMappings.FindL(mapping); for(; mappingIndex < mappingCount; ++mappingIndex) { aMappingArray.AppendL(iMappings[mappingIndex]); if ((mappingIndex >= (mappingCount - 1)) || (iMappings[mappingIndex].iCommandListId != iMappings[mappingIndex + 1].iCommandListId)) { //Breaking as it reached end of array or completed appending the mappings for //the given commandlist id break; } } DEBUGPRINT3(_L("Mapping Array for substate %04x Contains %d entries"), iMappings[mappingIndex].iCommandListId, aMappingArray.Count()); }
Mapping* FGeoSession::mapping(const SiPrefix* o) { (void) o; String mn = "SiPrefix"; if (hasMapping(mn)) { return mappingByName(mn); } Table* t = connection()->database()->table("core.si_prefixes"); Mapping* m = createMapping(mn, t); m->createProperty("id", t->column("id")); m->createProperty("name", t->column("name")); m->createProperty("code", t->column("code")); m->createProperty("symbol", t->column("symbol")); m->createProperty("description", t->column("description")); m->createProperty("factor", t->column("factor")); return mapping(o); }
int main(int argc, char **argv) { MPI_Init(&argc, &argv); #ifdef DEBUG printf("cache_node argc: %d\n", argc); for (int i = 0; i < argc; ++i) { printf("argv[%d]: %s\n", i, argv[i]); } #endif std::string mapping(argv[1]); //replace_commas(mapping); std::vector<uint32_t> map_vec; stringlist_to_vector(map_vec, mapping); CacheNode cache_node(map_vec); MPI_Finalize(); return 0; }
int tux_dir_is_empty(struct inode *dir) { struct sb *sb = tux_sb(dir->i_sb); block_t block, blocks = dir->i_size >> sb->blockbits; __be64 self = cpu_to_be64(tux_inode(dir)->inum); struct buffer_head *buffer; for (block = 0; block < blocks; block++) { buffer = blockread(mapping(dir), block); if (!buffer) return -EIO; tux_dirent *entry = bufdata(buffer); tux_dirent *limit = bufdata(buffer) + sb->blocksize - TUX_REC_LEN(1); for (; entry <= limit; entry = next_entry(entry)) { if (!entry->rec_len) { blockput(buffer); tux_zero_len_error(dir, block); return -EIO; } if (is_deleted(entry)) continue; if (entry->name[0] != '.') goto not_empty; if (entry->name_len > 2) goto not_empty; if (entry->name_len < 2) { if (entry->inum != self) goto not_empty; } else if (entry->name[1] != '.') goto not_empty; } blockput(buffer); } return 0; not_empty: blockput(buffer); return -ENOTEMPTY; }
void CSsmCommandListResourceReaderImpl::CInitialiser::ParseFileL(CResourceFile* aResourceFile) { // read root resource RResourceReader rootReader; const TInt KRootResourceId = 1; rootReader.OpenLC(aResourceFile, KRootResourceId); const TSsmResourceVersion version = static_cast<TSsmResourceVersion>(rootReader.ReadInt16L()); if (version != ESsmInitialVersion) { SSMLOGLEAVE(KErrNotSupported); } const TInt reserved1 = rootReader.ReadInt16L(); // skip SSM_COMMAND_LIST_ROOT.reserved1 const TInt commandListMappingResourceId = rootReader.ReadInt32L(); if (commandListMappingResourceId <= 0) { DEBUGPRINT1(_L("Command list resource file contains no mappings")); SSMLOGLEAVE(KErrNotFound); } CleanupStack::PopAndDestroy(&rootReader); // read mapping resource RResourceReader mappingReader; mappingReader.OpenLC(aResourceFile, commandListMappingResourceId); const TInt mappingCount = mappingReader.ReadInt16L(); if (!mappingCount) { DEBUGPRINT1(_L("Command list resource file contains no mappings")); SSMLOGLEAVE(KErrNotFound); } for (TInt i = 0; i < mappingCount; i++) { // add each mapping to the pool TUint commandListId = mappingReader.ReadUint32L(); TInt resourceId = mappingReader.ReadInt32L(); TMapping mapping(commandListId, resourceId, aResourceFile); iResourcePool.AppendL(mapping); } CleanupStack::PopAndDestroy(&mappingReader); }
message message::extract_impl(size_t start, message_handler handler) const { auto s = size(); for (size_t i = start; i < s; ++i) { for (size_t n = (s - i) ; n > 0; --n) { auto next_slice = slice(i, n); auto res = handler(next_slice); if (res) { std::vector<size_t> mapping(s); std::iota(mapping.begin(), mapping.end(), size_t{0}); auto first = mapping.begin() + static_cast<ptrdiff_t>(i); auto last = first + static_cast<ptrdiff_t>(n); mapping.erase(first, last); if (mapping.empty()) { return message{}; } message next{detail::decorated_tuple::make(vals_, std::move(mapping))}; return next.extract_impl(i, handler); } } } return *this; }
bool OBJECT_WAREHOUSE_CLASS::addMappedValue(char *name_ptr, char *value_ptr, UINT16 group, UINT16 element, LOG_CLASS *logger_ptr, bool userDefined) // DESCRIPTION : Method to add a Name / Value mapping to the mapping list. // PRECONDITIONS : // POSTCONDITIONS : // EXCEPTIONS : // NOTES : //<<=========================================================================== { if (logger_ptr) { logger_ptr->text(LOG_DEBUG, 1, "OBJECT_WAREHOUSE_CLASS::addMappedValue(name_ptr:= %s value_ptr:= %s)", name_ptr, value_ptr); } char *existingValue_ptr; // check if Value has already been defined if ((existingValue_ptr = getMappedValue(name_ptr, logger_ptr)) != NULL) { if (strcmp(existingValue_ptr, value_ptr) != 0) { // Name previously given to different Value // - modify the Name / Value mapping modifyMappedValue(name_ptr, value_ptr, group, element, logger_ptr); } } else { // instaniate a new Name / Value mapping WAREHOUSE_MAPPING_CLASS mapping(name_ptr, value_ptr, group, element, userDefined); // add Name / Value mapping mappingM.add(mapping); } // return result return true; }
virtual void operator()(utils::kernel_generation_stream & stream, std::size_t device_offset, statements_type const & statements) const { std::vector<detail::mapping_type> mapping(statements.size()); ///Get Prototype, initialize mapping std::string prototype; std::set<std::string> already_generated; kernel_arguments(statements, prototype); { std::map<void *, std::size_t> memory; unsigned int current_arg = 0; std::size_t i = 0; for(statements_type::const_iterator it = statements.begin() ; it != statements.end() ; ++it) detail::traverse(it->first, it->second, detail::map_functor(memory,current_arg,mapping[i++])); } for(statements_type::const_iterator it = statements.begin() ; it != statements.end() ; ++it){ detail::traverse(it->first, it->second, detail::prototype_generation_traversal(already_generated, prototype, vectorization(), mapping[std::distance(statements.begin(), it)])); } prototype.erase(prototype.size()-1); //Last comma pruned //Generate for(std::size_t n = 0 ; n < num_kernels() ; ++n){ //stream << "__attribute__((vec_type_hint()))" << std::endl; stream << " __attribute__((reqd_work_group_size(" << local_size_1_ << "," << local_size_2_ << "," << 1 << ")))" << std::endl; stream << "__kernel " << "void " << "kernel_" << device_offset << "_" << n << "(" << std::endl; stream << prototype << std::endl; stream << ")" << std::endl; //core: stream << "{" << std::endl; stream.inc_tab(); core(n, stream, statements, mapping); stream.dec_tab(); stream << "}" << std::endl; } }
END_TEST START_TEST (sequence_iteration) { reset_errno(); Node *r = model_document_root(model, 0); assert_noerr(); assert_not_null(r); assert_node_kind(r, MAPPING); reset_errno(); Node *s = mapping_get(mapping(r), (uint8_t *)"one", 3ul); assert_noerr(); assert_not_null(s); assert_node_kind(s, SEQUENCE); assert_node_size(s, 2); size_t count = 0; reset_errno(); assert_true(sequence_iterate(sequence(s), check_sequence, &count)); assert_noerr(); assert_uint_eq(2, count); }
/** * Create a couple of simple way strings and verify that the generated subline match is correct. */ void runTest() { OsmMapPtr map(new OsmMap()); NodePtr n1a = TestUtils::createNode(map, Status::Unknown1, 0, 0); NodePtr n1b = TestUtils::createNode(map, Status::Unknown1, 100, 0); NodePtr n1c = TestUtils::createNode(map, Status::Unknown1, 200, 0); WayPtr w1 = TestUtils::createWay(map, QList<NodePtr>() << n1a << n1b); WayPtr w2 = TestUtils::createWay(map, QList<NodePtr>() << n1b << n1c); NodePtr n2a = TestUtils::createNode(map, Status::Unknown1, 0, 10); NodePtr n2b = TestUtils::createNode(map, Status::Unknown1, 150, 10); NodePtr n2c = TestUtils::createNode(map, Status::Unknown1, 210, 10); WayPtr w3 = TestUtils::createWay(map, QList<NodePtr>() << n2a << n2b); WayPtr w4 = TestUtils::createWay(map, QList<NodePtr>() << n2c << n2b); WayStringPtr wstr1(new WayString()); wstr1->append(WaySubline(WayLocation(map, w1, 0), WayLocation::createAtEndOfWay(map, w1))); wstr1->append(WaySubline(WayLocation(map, w2, 0), WayLocation::createAtEndOfWay(map, w2))); WayStringPtr wstr2(new WayString()); wstr2->append(WaySubline(WayLocation(map, w3, 0), WayLocation::createAtEndOfWay(map, w3))); wstr2->append(WaySubline(WayLocation::createAtEndOfWay(map, w4), WayLocation(map, w4, 0))); WayMatchStringMappingPtr mapping(new NaiveWayMatchStringMapping(wstr1, wstr2)); WaySublineMatchStringPtr wsms = WayMatchStringMappingConverter(). toWaySublineMatchString(mapping); //LOG_VAR(TestUtils::toQuotedString(hoot::toString(wsms))); HOOT_STR_EQUALS("matches:\n" "subline 1: start: way(-1) index: 0 fraction: 0 end: way(-1) index: 1 fraction: 0\n" "subline 2: start: way(-3) index: 0 fraction: 0 end: way(-3) index: 0 fraction: 0.7\n" "subline 1: start: way(-2) index: 0 fraction: 0 end: way(-2) index: 0 fraction: 0.428571428571429\n" "subline 2: start: way(-3) index: 0 fraction: 0.7 end: way(-3) index: 1 fraction: 0\n" "reversed, subline 1: start: way(-2) index: 0 fraction: 0.428571428571429 end: way(-2) index: 1 fraction: 0\n" "subline 2: start: way(-4) index: 0 fraction: 0 end: way(-4) index: 1 fraction: 0", wsms); }
int main() { Process::cd("/tmp"); File file("testMemoryMapping.XXXXXX"); file.createUnique(); file.unlinkOnExit(); print("(parent) file.path() = \"%%\"\n", file.path()); file.open(File::Read|File::Write); file.truncate(mapLength); print("(parent) acquiring write lock... \n"); FileLock lock(&file, FileLock::Write); lock.acquire(); print("(parent) mapping file and writing message... \n"); { MemoryMapping mapping(&file, 0, mapLength); String message = "Hello, clone!"; mem::cpy(reinterpret_cast<char*>(mapping.start()), message->data(), message->size()); } print("(parent) cloning myself... \n"); Ref<CloneFactory, Owner> factory = new CloneFactory(file.path()); Ref<Process, Owner> fork = factory->produce(); //print("(parent) sleeping 2 seconds... \n"); //Thread::sleep(2); print("(parent) releasing write lock... \n"); lock.release(); int ret = fork->wait(); print("(parent) clone terminated, ret = %%\n", ret); return 0; }
//-> void init_builtin_syslog() { boost::shared_ptr< logging::core > core = logging::core::get(); // Create a new backend boost::shared_ptr< sinks::syslog_backend > backend(new sinks::syslog_backend( keywords::facility = sinks::syslog::local0, /*< the logging facility >*/ keywords::use_impl = sinks::syslog::udp_socket_based /*< the built-in socket-based implementation should be used >*/ )); // Setup the target address and port to send syslog messages to backend->set_target_address("192.164.1.10", 514); // Create and fill in another level translator for "MyLevel" attribute of type string sinks::syslog::custom_severity_mapping< std::string > mapping("MyLevel"); mapping["debug"] = sinks::syslog::debug; mapping["normal"] = sinks::syslog::info; mapping["warning"] = sinks::syslog::warning; mapping["failure"] = sinks::syslog::critical; backend->set_severity_mapper(mapping); // Wrap it into the frontend and register in the core. core->add_sink(boost::make_shared< sink_t >(backend)); }
void init_logging() { // Create an event log sink boost::shared_ptr< sink_t > sink(new sink_t()); sink->set_formatter ( expr::format("%1%: [%2%] - %3%") % expr::attr< unsigned int >("LineID") % expr::attr< boost::posix_time::ptime >("TimeStamp") % expr::smessage ); // We'll have to map our custom levels to the event log event types sinks::event_log::custom_event_type_mapping< severity_level > mapping("Severity"); mapping[normal] = sinks::event_log::info; mapping[warning] = sinks::event_log::warning; mapping[error] = sinks::event_log::error; sink->locked_backend()->set_event_type_mapper(mapping); // Add the sink to the core logging::core::get()->add_sink(sink); }
/*! Creates a content manager object for the scheme identified by \a scheme. */ QMailContentManager *QMailContentManagerFactory::create(const QString &scheme) { return mapping(scheme); }
var tau::operator()(const var&v){ var out; out.real=mapping(v.real); for_each_copy(v.dual->begin(),v.dual->end(),inserter(*(out.dual),out.dual->begin()),mul_make_pair<std::pair<int,double> >, primitive(v.real)); return out; }
result_type operator->() const { return mapping(Iterator::operator->()); }
cmph_t *fch_new(cmph_config_t *mph, double c) { cmph_t *mphf = NULL; fch_data_t *fchf = NULL; cmph_uint32 iterations = 100; cmph_uint8 restart_mapping = 0; fch_buckets_t * buckets = NULL; cmph_uint32 * sorted_indexes = NULL; fch_config_data_t *fch = (fch_config_data_t *)mph->data; fch->m = mph->key_source->nkeys; //DEBUGP("m: %f\n", fch->m); if (c <= 2) c = 2.6; // validating restrictions over parameter c. fch->c = c; //DEBUGP("c: %f\n", fch->c); fch->h1 = NULL; fch->h2 = NULL; fch->g = NULL; do { if (mph->verbosity) { fprintf(stderr, "Entering mapping step for mph creation of %u keys\n", fch->m); } if (buckets) fch_buckets_destroy(buckets); buckets = mapping(mph); if (mph->verbosity) { fprintf(stderr, "Starting ordering step\n"); } if (sorted_indexes) free (sorted_indexes); sorted_indexes = ordering(buckets); if (mph->verbosity) { fprintf(stderr, "Starting searching step.\n"); } restart_mapping = searching(fch, buckets, sorted_indexes); iterations--; } while(restart_mapping && iterations > 0); if (buckets) fch_buckets_destroy(buckets); if (sorted_indexes) free (sorted_indexes); if (iterations == 0) return NULL; mphf = (cmph_t *)malloc(sizeof(cmph_t)); mphf->algo = mph->algo; fchf = (fch_data_t *)malloc(sizeof(fch_data_t)); fchf->g = fch->g; fch->g = NULL; //transfer memory ownership fchf->h1 = fch->h1; fch->h1 = NULL; //transfer memory ownership fchf->h2 = fch->h2; fch->h2 = NULL; //transfer memory ownership fchf->p2 = fch->p2; fchf->p1 = fch->p1; fchf->b = fch->b; fchf->c = fch->c; fchf->m = fch->m; mphf->data = fchf; mphf->size = fch->m; //DEBUGP("Successfully generated minimal perfect hash\n"); if (mph->verbosity) { fprintf(stderr, "Successfully generated minimal perfect hash function\n"); } return mphf; }
int main(int argc, char ** argv) { fftw_complex *z; fftw_plan plan; gsl_rng *r; const gsl_rng_type *T; struct parms parms; double *phi, avg, ran, std; double *philocal; int Nx, Ny, Nz, size, rank, xnn; int i, j, n1, n2, irank, i0, j0; char filename[64]; FILE *file; void initrng(void); double uniform(void); MPI_Status status; Nx = atoi(argv[1]); Ny = atoi(argv[2]); Nz = atoi(argv[3]); avg = atof(argv[4]); std = atof(argv[5]); parms.Nx = Nx; parms.Ny = Ny; parms.Nz = Nz; // MPI MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size (MPI_COMM_WORLD, &size); if (rank == 0){ // RNG setup gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); printf ("r is a '%s' generator\n", gsl_rng_name (r)); for (i=0; i < 1000000; i++) ran = avg + gsl_ran_gaussian(r,std); xnn = Nx*Ny*Nz; phi = (double *) calloc(Nx*Ny*Nz, sizeof(double)); for (i = 0; i < Nx*Ny*Nz; i++){ ran = avg + gsl_ran_gaussian(r,std); phi[i] = (ran); } } parms.Nx = Nx; parms.Ny = Ny; parms.Nz = Nz; parms.rank = rank-1; parms.size = size-1; //Slave COMM parms = mapping(parms); philocal = (double *) calloc(parms.nx*parms.ny, sizeof(double)); if (rank == 0){ for (irank = 0; irank < parms.size; irank++){ parms.rank = irank; parms = mapping(parms); for (i = 0; i < parms.nx; i++) for (j = 0; j < parms.ny; j++){ i0 = parms.x0 + i; // Global coords j0 = parms.y0 + j; n1 = i*parms.ny + j; //Local index n2 = i0*parms.Ny + j0; //Global index philocal[n1] = phi[n2]; } n1 = parms.nx*parms.ny; MPI_Send(philocal, n1, MPI_DOUBLE, irank+1, 0, MPI_COMM_WORLD); } } else{ n1 = parms.nx*parms.ny; //Fill local height MPI_Recv(philocal, n1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status); sprintf(filename, "%s.%02d", "phi.dat", parms.rank); file = fopen(filename, "w"); fprintf(file, "%5d %5d %5d %5d %5d 0 0.0\n", parms.Nx, parms.Ny, parms.nx, parms.ny, parms.Nz); for (i = 0; i < parms.nx; i++) for (j = 0; j < parms.ny; j++){ fprintf(file, " % .3e", philocal[i*parms.ny+j]); if ((i*parms.ny+j+1)%10 == 0) fprintf(file, "\n"); } fclose(file); } MPI_Finalize(); return 0; }
int main(int argc, char** argv) { int verbose = 0; int node = -1; int access = O_RDONLY; // or O_RDWR; int count = 1; bool long_format = false; bool benchmark = false; const char* short_format = " %8x"; static struct option long_options[] = { {"node", required_argument, 0, 'n' }, {"read", no_argument, 0, 'r' }, {"verbose", no_argument, 0, 'v' }, {"write", no_argument, 0, 'w' }, {0, 0, 0, 0 } }; try { dyplo::HardwareContext ctrl; int option_index = 0; for (;;) { int c = getopt_long(argc, argv, "bc:dln:rvw", long_options, &option_index); if (c < 0) break; switch (c) { case 'b': benchmark = true; break; case 'c': count = strtol(optarg, NULL, 0); break; case 'd': short_format = " %8d"; break; case 'l': long_format = true; break; case 'n': node = strtol(optarg, NULL, 0); break; case 'r': access = O_RDONLY; break; case 'v': ++verbose; break; case 'w': access = O_RDWR; break; case '?': usage(argv[0]); return 1; } } dyplo::File file(node < 0 ? ctrl.openControl(access) : ctrl.openConfig(node, access)); if (access == O_RDONLY) { for (int index = optind; index < argc; ++index) { unsigned int addr = strtol(argv[index], NULL, 0); off_t page_location = addr & ~(PAGE_SIZE-1); unsigned int page_offset = addr & (PAGE_SIZE-1); size_t size = addr + (count * sizeof(unsigned int)) - page_location; if (verbose) printf("Addr: %#x (%d) offset=%#x+%#x - %#zx (%zu)\n", addr, addr, (unsigned int)page_location, page_offset, size, size); dyplo::MemoryMap mapping(file, page_location, size, PROT_READ); volatile unsigned int* data = (unsigned int*)(((char*)mapping.memory) + page_offset); if (benchmark) { unsigned int loops = 0; Stopwatch timer; if (count > 1) { size_t blocksize = count * sizeof(unsigned int); unsigned int dest[count]; timer.start(); do { for (unsigned int repeat = 64*1024u; repeat != 0; --repeat) { memcpy(dest, (void*)data, blocksize); } ++loops; timer.stop(); } while (timer.elapsed_us() < 1000000); } else { count = 1; timer.start(); do { unsigned int dest; for (unsigned int repeat = 64*1024u; repeat != 0; --repeat) { dest += *data; /* force memory access */ } ++loops; timer.stop(); } while (timer.elapsed_us() < 1000000); } unsigned int elapsed_us = timer.elapsed_us(); unsigned int bytes = loops * count * (64u * 1024u * sizeof(unsigned int)); printf("loops=%u us=%u bytes=%u hence %u MB/s\n", loops, elapsed_us, bytes, bytes / elapsed_us); } else { if (long_format) { for (int i = 0; i < count; ++i) { unsigned int value = data[i]; printf("@0x%04x: %#10x (%d)\n", (unsigned int)(addr+(i*sizeof(unsigned int))), value, (int)value); } } else { int j = 0; int lines = (count+3)/4; for (int line = 0; line < lines; ++line) { printf("@0x%04x: ", (unsigned int)(addr + (j*sizeof(unsigned int)))); for (int i = j; i < count && i < j+4; ++i) { unsigned int value = data[i]; printf(short_format, value); } printf("\n"); j += 4; } } } } } else { if (argc - optind < 2) throw std::runtime_error("Too few arguments for write mode, need address and value(s)"); unsigned int addr = strtol(argv[optind], NULL, 0); ++optind; unsigned int values = argc - optind; off_t page_location = addr & ~(PAGE_SIZE-1); unsigned int page_offset = addr & (PAGE_SIZE-1); size_t size = addr + (values * sizeof(unsigned int)) - page_location; if (verbose) printf("Addr: %#x (%d) offset=%#x+%#x - %#zx (%zu)\n", addr, addr, (unsigned int)page_location, page_offset, size, size); dyplo::MemoryMap mapping(file, page_location, size, PROT_READ|PROT_WRITE); volatile unsigned int* data = (unsigned int*)(((char*)mapping.memory) + page_offset); unsigned int value[values]; const size_t blocksize = values * sizeof(unsigned int); for (int index = 0; index < values; ++index) value[index] = strtoul(argv[optind+index], NULL, 0); if (verbose) { printf("transfer size: %d words, %zd bytes\n", values, blocksize); for (int index = 0; index < values; ++index) printf("%x (%d)\n", value[index], (int)value[index]); } if (benchmark) { unsigned int loops = 0; Stopwatch timer; timer.start(); do { for (unsigned int repeat = 64*1024u; repeat != 0; --repeat) { memcpy((void*)data, value, blocksize); } ++loops; timer.stop(); } while (timer.elapsed_us() < 1000000); unsigned int elapsed_us = timer.elapsed_us(); unsigned int bytes = loops * blocksize * (64u * 1024u); printf("loops=%u us=%u bytes=%u hence %u MB/s\n", loops, elapsed_us, bytes, bytes / elapsed_us); } else { memcpy((void*)data, value, blocksize); } } } catch (const std::exception& ex) { std::cerr << "ERROR:\n" << ex.what() << std::endl; return 1; } return 0; }
void parseFile(FILE *f, Normalizer2DataBuilder &builder) { IcuToolErrorCode errorCode("gennorm2/parseFile()"); char line[300]; uint32_t startCP, endCP; while(NULL!=fgets(line, (int)sizeof(line), f)) { char *comment=(char *)strchr(line, '#'); if(comment!=NULL) { *comment=0; } u_rtrim(line); if(line[0]==0) { continue; // skip empty and comment-only lines } if(line[0]=='*') { const char *s=u_skipWhitespace(line+1); if(0==strncmp(s, "Unicode", 7)) { s=u_skipWhitespace(s+7); builder.setUnicodeVersion(s); } continue; // reserved syntax } const char *delimiter; int32_t rangeLength= u_parseCodePointRangeAnyTerminator(line, &startCP, &endCP, &delimiter, errorCode); if(errorCode.isFailure()) { fprintf(stderr, "gennorm2 error: parsing code point range from %s\n", line); exit(errorCode.reset()); } delimiter=u_skipWhitespace(delimiter); if(*delimiter==':') { const char *s=u_skipWhitespace(delimiter+1); char *end; unsigned long value=strtoul(s, &end, 10); if(end<=s || *u_skipWhitespace(end)!=0 || value>=0xff) { fprintf(stderr, "gennorm2 error: parsing ccc from %s\n", line); exit(U_PARSE_ERROR); } for(UChar32 c=(UChar32)startCP; c<=(UChar32)endCP; ++c) { builder.setCC(c, (uint8_t)value); } continue; } if(*delimiter=='-') { if(*u_skipWhitespace(delimiter+1)!=0) { fprintf(stderr, "gennorm2 error: parsing remove-mapping %s\n", line); exit(U_PARSE_ERROR); } for(UChar32 c=(UChar32)startCP; c<=(UChar32)endCP; ++c) { builder.removeMapping(c); } continue; } if(*delimiter=='=' || *delimiter=='>') { UChar uchars[Normalizer2Impl::MAPPING_LENGTH_MASK]; int32_t length=u_parseString(delimiter+1, uchars, LENGTHOF(uchars), NULL, errorCode); if(errorCode.isFailure()) { fprintf(stderr, "gennorm2 error: parsing mapping string from %s\n", line); exit(errorCode.reset()); } UnicodeString mapping(FALSE, uchars, length); if(*delimiter=='=') { if(rangeLength!=1) { fprintf(stderr, "gennorm2 error: round-trip mapping for more than 1 code point on %s\n", line); exit(U_PARSE_ERROR); } builder.setRoundTripMapping((UChar32)startCP, mapping); } else { for(UChar32 c=(UChar32)startCP; c<=(UChar32)endCP; ++c) { builder.setOneWayMapping(c, mapping); } } continue; } fprintf(stderr, "gennorm2 error: unrecognized data line %s\n", line); exit(U_PARSE_ERROR); } }
int main (int argc, char **argv) { // double *A_local; int A_descrip[DESC_SIZE]; // double *B_local; int B_descrip[DESC_SIZE]; // double *C_local; int C_descrip[DESC_SIZE]; int nproc_rows; int nproc_cols; int m, n, k; int blacs_grid; int myproc, nprocs; char myname[MPI_MAX_PROCESSOR_NAME]; double *a, *b, *c; /* Get input parameters */ m = GLOBAL_M; n = GLOBAL_N; k = GLOBAL_K; // 32 MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &myproc); /* Ensure we have at least two processors */ if (nprocs < 2) { printf("Too few processors!\n"); exit (1); } if(gethostname (myname, MPI_MAX_PROCESSOR_NAME) != 0 ) printf("Error: gethostname failed!\n"); else if(HELLO) printf("Hello from %2d of %2d on %s\n", myproc, nprocs, myname); /* Set to HIGH frequency */ mapping(myproc%7, DVFS_HIGH); Cblacs_get(0, 0, &blacs_grid); int ldumap=PROC_NODE; nproc_rows=PROC_NODE; nproc_cols=PROC_NODE; /* ROW MAJOR TILING */ if(MAJOR==1) { int usermap[64]= {0, 1, 8, 9, 16, 17, 24, 25, 2, 3, 10, 11, 18, 19, 26, 27, 4, 5, 12, 13, 20, 21, 28, 29, 6, 7, 14, 15, 22, 23, 30, 31, 32, 33, 40, 41, 48, 49, 56, 57, 34, 35, 42, 43, 50, 51, 58, 59, 36, 37, 44, 45, 52, 53, 60, 61, 38, 39, 46, 47, 54, 55, 62, 63}; Cblacs_gridmap(&blacs_grid, usermap, ldumap, nproc_rows, nproc_cols); } else if (MAJOR==2) /* COLUMN MAJOR TILING*/ { int usermap[64]={0, 1, 2, 3, 8, 9, 10, 11, 4, 5, 6, 7, 12, 13, 14, 15, 16, 17, 18, 19, 24, 25, 26, 27, 20, 21, 22, 23, 28, 29, 30, 31, 32, 33, 34, 35, 40, 41, 42, 43, 36, 37, 38, 39, 44, 45, 46, 47, 48, 49, 50, 51, 56, 57, 58, 59, 52, 53, 54, 55, 60, 61, 62, 63}; Cblacs_gridmap(&blacs_grid, usermap, ldumap, nproc_rows, nproc_cols); } else if(MAJOR==0) Cblacs_gridinit(&blacs_grid, "R", nproc_rows, nproc_cols); // Cblacs_pcoord(blacs_grid, myproc, &my_process_row, &my_process_col); int local_m = m/nproc_rows; int local_n = n/nproc_cols; int local_k = k/nproc_cols; if(myproc==SHOW1) printf("local m n k = %d %d %d\n",local_m, local_n, local_k); a = (double *) malloc (local_m*local_k * sizeof(double)); b = (double *) malloc (local_k*local_n * sizeof(double)); c = (double *) malloc (local_m*local_n * sizeof(double)); // A_local = (double *) malloc (local_m*local_k * sizeof(double)); // B_local = (double *) malloc (local_k*local_n * sizeof(double)); // C_local = (double *) malloc (local_m*local_n * sizeof(double)); if(!a||!b||!c)//||!A_local||!B_local||!C_local) { printf("out of memory!\n"); exit(-1); } Build_descrip(myproc, "A", A_descrip, m, k, local_m, local_k, blacs_grid, local_m);//MAX(local_m, local_k)); Build_descrip(myproc, "B", B_descrip, k, n, local_k, local_n, blacs_grid, local_k);//MAX(local_k, local_n)); Build_descrip(myproc, "C", C_descrip, m, n, local_m, local_n, blacs_grid, local_m);//MAX(local_m, local_n)); if(myproc==SHOW1) { printf("\nA_descrip = [ %d, %d, %d, %d, %d, %d, %d, %d, %d]\n", A_descrip[0], A_descrip[1], A_descrip[2], A_descrip[3], A_descrip[4], A_descrip[5], A_descrip[6], A_descrip[7], A_descrip[8]); printf("\nB_descrip = [ %d, %d, %d, %d, %d, %d, %d, %d, %d]\n", B_descrip[0], B_descrip[1], B_descrip[2], B_descrip[3], B_descrip[4], B_descrip[5], B_descrip[6], B_descrip[7], B_descrip[8]); printf("\nC_descrip = [ %d, %d, %d, %d, %d, %d, %d, %d, %d]\n\n", C_descrip[0], C_descrip[1], C_descrip[2], C_descrip[3], C_descrip[4], C_descrip[5], C_descrip[6], C_descrip[7], C_descrip[8]); } int ij = 1; char tran = 'N'; double alpha = 1.0, beta = 1.0; double exetime=0; MPI_Barrier(MPI_COMM_WORLD); if(MEASURE && myproc==0) { system("/apps/power-bench/mclient -H 10.1.255.100 -d /tmp"); system("/apps/power-bench/mclient -H 10.1.255.100 -l pdgemm.ptr"); system("/apps/power-bench/mclient -H 10.1.255.100 -s pdgemm"); } // Zeros(A_local, local_m, local_k); // Zeros(B_local, local_k, local_n); // Zeros(C_local, local_m, local_n); // if(myproc%8==0) // RndMatrix(A_local, local_m, local_k, myproc); // if(myproc<8) // RndMatrix(B_local, local_k, local_n, myproc); MPI_Barrier(MPI_COMM_WORLD); // exetime0 = -MPI_Wtime(); // ScaLAPACK pdgemm if(!myproc) printf("\nM = %d, N = %d, K = %d\n", m, n, k); /* pdgemm_(&tran, &tran, &m, &n, &k, &alpha, A_local, &ij, &ij, A_descrip, B_local, &ij, &ij, B_descrip, &beta, C_local, &ij, &ij, C_descrip); MPI_Barrier(MPI_COMM_WORLD); exetime0 += MPI_Wtime(); CpyMatrix(A_local, a, local_m, local_k); CpyMatrix(B_local, b, local_k, local_n); Zeros(c, local_m, local_n); */ // if(myproc%8==0) RndMatrix(a, local_m, local_k, myproc); // if(myproc<8) RndMatrix(b, local_k, local_n, myproc); Zeros(c, local_m, local_n); MPI_Barrier(MPI_COMM_WORLD); exetime = -MPI_Wtime(); // My pdgemm pdgemm(&tran, &tran, &m, &n, &k, &alpha, a, &ij, &ij, A_descrip, b, &ij, &ij, B_descrip, &beta, c, &ij, &ij, C_descrip); //printf("MYPDGEMM finish\n"); MPI_Barrier(MPI_COMM_WORLD); exetime += MPI_Wtime(); if(MEASURE && myproc==0) { system("/apps/power-bench/mclient -H 10.1.255.100 -e session"); system("/apps/power-bench/mclient -H 10.1.255.100 -e log"); } mapping(myproc%7, DVFS_LOW); mapping(0, DVFS_HIGH); if(myproc == SHOW1) { sleep(1); //printf("Total execution time of my_pdgemm is %.3f.\n", exetime); printf("Total execution time of pdgemm is %.3f.\n", exetime); int i, j; /* printf("My PDGEMM ID AAA = %d :\n",myproc); for(i=0;i<DISP_SIZE;i++) { for(j=0;j<DISP_SIZE;j++) printf("%8.5lf ", a[i*DISP_SIZE+j]); printf("\n"); } printf("My PDGEMM ID BBB = %d :\n",myproc); for(i=0;i<DISP_SIZE;i++) { for(j=0;j<DISP_SIZE;j++) printf("%8.5lf ", b[i*DISP_SIZE+j]); printf("\n"); } */ /* printf("My PDGEMM ID CCC = %d :\n",myproc); for(i=0;i<DISP_SIZE;i++) { for(j=0;j<DISP_SIZE;j++) printf("%10.5lf\t", c[i*DISP_SIZE+j]); printf("\n"); } */ /* } if(myproc == SHOW2) { sleep(3); printf("Total execution time of my_pdgemm is %.3f.\n", exetime); printf("Total execution time of pdgemm is %.3f.\n", exetime0); int i, j; printf("PDGEMM ID AAA = %d :\n",myproc); for(i=0;i<DISP_SIZE;i++) { for(j=0;j<DISP_SIZE;j++) printf("%8.5lf ", A_local[i*DISP_SIZE+j]); printf("\n"); } printf("PDGEMM ID BBB = %d :\n",myproc); for(i=0;i<DISP_SIZE;i++) { for(j=0;j<DISP_SIZE;j++) printf("%8.5lf ", B_local[i*DISP_SIZE+j]); printf("\n"); } */ printf("PDGEMM ID CCC = %d :\n",myproc); for(i=0;i<DISP_SIZE;i++) { for(j=0;j<DISP_SIZE;j++) printf("%10.5lf\t", c[i*DISP_SIZE+j]); printf("\n"); } } // double diffa, diffb, diffc, diff_total=0.0; //diffa=diff_norm(A_local, a, local_m, local_k); //diffb=diff_norm(B_local, b, local_k, local_n); //diffc=diff_norm(C_local, c, local_m, local_n); //MPI_Reduce(&diffa, &diff_total, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); // sleep(1); /* if(!myproc) printf("The total normal difference between my pdgemm A and ScaLAPACK pdgemm A is %e.\n", diff_total); MPI_Reduce(&diffb, &diff_total, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); sleep(1); if(!myproc) printf("The total normal difference between my pdgemm B and ScaLAPACK pdgemm B is %e.\n", diff_total); MPI_Reduce(&diffc, &diff_total, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); sleep(1); if(!myproc) printf("The total normal difference between my pdgemm C and ScaLAPACK pdgemm C is %e.\n", diff_total); */ free(a); free(b); free(c); //free(A_local);free(B_local);free(C_local); Cblacs_exit(1); /* Clean-up and close down */ MPI_Barrier(MPI_COMM_WORLD); //MPI_Comm_free(&my_row_comm); //MPI_Comm_free(&my_column_comm); MPI_Finalize(); return 0; }
void pdgemm(char *TRANSA, char *TRANSB, int *M, int *N, int *K, double *ALPHA, double *a, int *IA, int *JA, int *DESCA, double *b, int *IB, int *JB, int *DESCB, double *BETA, double *c, int *IC, int *JC, int *DESCC) { // int my_row, my_column; int bk = BLOCK_SIZE; int n; int i, j, k, round; int r_rank, c_rank, g_rank, g_size; double *tempA, *tempB; double *tmpA, *tmpB; double t_bc, t_calc, t_tot, t_bar; double tt_bc, tt_calc, tt_tot, tt_bar; double sum, g_sum; int num_bk, loops, roots; int pk, last=0; int nprow, npcol, myrow, mycol; int *position, *coordinate; MPI_Comm my_row_comm, my_column_comm; /* Get the rank of the global communicator */ MPI_Comm_rank(MPI_COMM_WORLD, &g_rank); MPI_Comm_size(MPI_COMM_WORLD, &g_size); Cblacs_gridinfo( (ctxt = DESCC[DCTXT]), &nprow, &npcol, &myrow, &mycol); // printf("nprow = %d, npcol = %d, myrow = %d, mycol = %d\n", nprow, npcol, myrow, mycol); pk = PIPE_SIZE; if(nprow == npcol) n = DESCA[DN]/nprow; // local size else { printf("The grid of process should be square.\n"); exit(-1); } coordinate = (int *)malloc(2*sizeof(int)); position = (int *)malloc(g_size*sizeof(int)); //MPI_Allgather(pos, 1, MPI_INT, position, g_size, MPI_INT, MPI_COMM_WORLD); for(i=0; i<g_size; i++) position[i]=i; MPI_Barrier(MPI_COMM_WORLD); // CreatTiling(position); //CreateReduceCommunicator(position, coordinate, &my_row_comm, &my_column_comm); //my_row = coordinate[0]; //my_column = coordinate[1]; /* Create my row and column communicators */ MPI_Comm_split(MPI_COMM_WORLD, mycol, myrow, &my_column_comm); MPI_Comm_split(MPI_COMM_WORLD, myrow, mycol, &my_row_comm); /* Get the rank of the local row communicator */ //MPI_Comm_rank(ctxtr->scp->comm, &r_rank); MPI_Comm_rank(my_row_comm, &r_rank); /* Get the rank of the local column communicator */ MPI_Comm_rank(my_column_comm, &c_rank); //MPI_Comm_rank(ctxtc->scp->comm, &c_rank); if(r_rank == 0 ) printf("my c_rank = %d\n", c_rank); tempA = (double *) malloc (n*bk * sizeof(double)); tempB = (double *) malloc (bk*n * sizeof(double)); //const enum CBLAS_ORDER Order=CblasRowMajor; //const enum CBLAS_TRANSPOSE TA=CblasNoTrans; //const enum CBLAS_TRANSPOSE TB=CblasNoTrans; sum = g_sum = 0.0; tt_bc = tt_calc = tt_tot = t_bar = 0.0; tt_tot = tt_bc = tt_calc = tt_bar = 0.0; num_bk =(n/bk); last = n%bk; tmpA = (double *) malloc (n*last * sizeof(double)); tmpB = (double *) malloc (last*n * sizeof(double)); if(last==0) loops = rows*num_bk; else { num_bk++; loops = rows*num_bk; } if(TIMER) t_tot = MPI_Wtime(); for(round=0; round<loops; round++) { k = (round%num_bk)*bk; roots = round/num_bk; if(*TRANSA == 'N') { if(r_rank == roots) { if(last!=0 && (round+1)%num_bk==0) // the last block of this process { for(i=0; i<last; i++) for(j=0; j<n; j++) { tmpA[i*n+j] = a[(k+i)*n+j]; } } else { for(i=0; i<bk; i++) for(j=0; j<n; j++) { tempA[i*n+j] = a[(k+i)*n+j]; } } } if(c_rank == roots) { if(last!=0 && (round+1)%num_bk==0) // the last block of this process { for(i=0; i<n; i++) for(j=0; j<last; j++) { tmpB[i*last+j] = b[i*n+(k+j)]; } } else { for(i=0; i<n; i++) for(j=0; j<bk; j++) { tempB[i*bk+j] = b[i*n+(k+j)]; } } } } else if( *TRANSA == 'T') { if(r_rank == roots) { if(last!=0 && (round+1)%num_bk==0) // the last block of this process { for(i=0; i<n; i++) for(j=0; j<last; j++) { tmpA[i*last+j] = a[i*n+(k+j)]; } } else { for(i=0; i<n; i++) for(j=0; j<bk; j++) { tempA[i*bk+j] = a[i*n+(k+j)]; } } } if(c_rank == roots) { if(last!=0 && (round+1)%num_bk==0) // the last block of this process { for(i=0; i<last; i++) for(j=0; j<n; j++) { tmpB[i*n+j] = b[(k+i)*n+j]; } } else { for(i=0; i<bk; i++) for(j=0; j<n; j++) { tempB[i*n+j] = b[(k+i)*n+j]; } } } } if(TIMER) t_bc = MPI_Wtime(); /* Broadcast to right */ if(PIPE) { if(last!=0 && (round+1)%num_bk==0) // the last block of this process MY_Bcast(tmpA, n*last, MPI_DOUBLE, roots, my_row_comm, r_rank, columns, pk); else MY_Bcast(tempA, n*bk, MPI_DOUBLE, roots, my_row_comm, r_rank, columns, pk); } else { if(last!=0 && (round+1)%num_bk==0) // the last block of this process MPI_Bcast(tmpA, last*n, MPI_DOUBLE, roots, my_row_comm); else MPI_Bcast(tempA, bk*n, MPI_DOUBLE, roots, my_row_comm); } /* Broadcast below */ if(PIPE) { if(last!=0 && (round+1)%num_bk==0) // the last block of this process MY_Bcast(tmpB, last*n, MPI_DOUBLE, roots, my_column_comm, c_rank, rows, pk); else MY_Bcast(tempB, bk*n, MPI_DOUBLE, roots, my_column_comm, c_rank, rows, pk); } else { if(last!=0 && (round+1)%num_bk==0) // the last block of this process MPI_Bcast(tmpB, n*last, MPI_DOUBLE, roots, my_column_comm); else MPI_Bcast(tempB, n*bk, MPI_DOUBLE, roots, my_column_comm); } if(TIMER) { t_bc = MPI_Wtime() - t_bc; tt_bc += t_bc; t_calc = MPI_Wtime(); } if(DVFS_ENABLE) mapping(g_rank%8, DVFS_HIGH); /* Do the multiplication */ if(*TRANSA == 'N') { if(last!=0 && (round+1)%num_bk==0) // the last block of this process dgemm_(TRANSA, TRANSB, &n, &n, &last, ALPHA, tmpA, &n, tmpB, &last, BETA, c, &n); else dgemm_(TRANSA, TRANSB, &n, &n, &bk, ALPHA, tempA, &n, tempB, &bk, BETA, c, &n); } else if(*TRANSA == 'T') { if(last!=0 && (round+1)%num_bk==0) // the last block of this process dgemm_(TRANSA, TRANSB, &n, &n, &last, ALPHA, tmpA, &last, tmpB, &n, BETA, c, &n); else dgemm_(TRANSA, TRANSB, &n, &n, &bk, ALPHA, tempA, &bk, tempB, &n, BETA, c, &n); } // dgemm_(TRANSA, TRANSB, &n, &n, &bk, ALPHA, tempA, &n, tempB, &bk, BETA, c, &n); // cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n, n, bk, alpha, tempA, bk, tempB, n, beta, c, n); /* check the calculate results*/ if(DVFS_ENABLE) mapping(g_rank%8, DVFS_LOW); if(TIMER) { t_calc = MPI_Wtime() - t_calc; tt_calc += t_calc; } } if(TIMER) { t_tot = MPI_Wtime() - t_tot; tt_tot += t_tot; MPI_Reduce(&tt_tot, &t_tot, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&tt_bc, &t_bc, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&tt_calc, &t_calc, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); if(g_rank == 0) printf("tot = %10.6f, bc = %10.6f, calc = %10.6f\n", t_tot, t_bc, t_calc); } MPI_Barrier(MPI_COMM_WORLD); free(tmpA);free(tmpB); // free(a); free(b); free(c); free(tempA); free(tempB); }
void pdgemm(char *TRANSA, char *TRANSB, int *M, int *N, int *K, double *ALPHA, double *a, int *IA, int *JA, int *DESCA, double *b, int *IB, int *JB, int *DESCB, double *BETA, double *c, int *IC, int *JC, int *DESCC) { int m, n, k; int i, j, round; int r_rank, c_rank, g_rank, g_size; double *tempA, *tempB; double t_bc, t_calc, t_tot, t_bar; double tt_bc, tt_calc, tt_tot, tt_bar; double sum, g_sum; int roots; int pk; int nprow, npcol, myrow, mycol; MPI_Comm my_row_comm, my_column_comm; /* Get the rank of the global communicator */ MPI_Comm_rank(MPI_COMM_WORLD, &g_rank); MPI_Comm_size(MPI_COMM_WORLD, &g_size); Cblacs_gridinfo( (ctxt = DESCC[DCTXT]), &nprow, &npcol, &myrow, &mycol); rows = nprow; columns = npcol; pk = PIPE_SIZE; m = DESCA[DM]/nprow; n = DESCB[DN]/nprow; k = DESCA[DN]/npcol; // local m n k size // printf("nprow = %d, npcol = %d\n\n",nprow, npcol); MPI_Barrier(MPI_COMM_WORLD); // printf("---step 1:myrow = %d, mycol = %d\n\n",myrow, mycol); /* Create my row and column communicators */ MPI_Comm_split(MPI_COMM_WORLD, mycol, myrow, &my_column_comm); MPI_Comm_split(MPI_COMM_WORLD, myrow, mycol, &my_row_comm); /* Get the rank of the local row communicator */ MPI_Comm_rank(my_row_comm, &r_rank); /* Get the rank of the local column communicator */ MPI_Comm_rank(my_column_comm, &c_rank); tempA = (double *) malloc (m*k * sizeof(double)); tempB = (double *) malloc (k*n * sizeof(double)); //const enum CBLAS_ORDER Order=CblasRowMajor; //const enum CBLAS_TRANSPOSE TA=CblasNoTrans; //const enum CBLAS_TRANSPOSE TB=CblasNoTrans; sum = g_sum = 0.0; tt_bc = tt_calc = tt_tot = t_bar = 0.0; tt_tot = tt_bc = tt_calc = tt_bar = 0.0; if(TIMER) t_tot = MPI_Wtime(); /* FT part, sum of A columnwise and B rowwise */ // A part // if(mycol < 7) { if(myrow < 7) { for(i=0; i<m; i++) for(j=0; j<k; j++) { tempA[i*k+j] = a[i*k+j]; } } // if(mycol == 6) // printf("a = %f\n", a[0]); MPI_Reduce(tempA, a, m*k, MPI_DOUBLE, MPI_SUM, 7, my_column_comm); //if(mycol == 6 && myrow == 7) // printf("A = %f\n", a[0]); } if(myrow < 7) { if(mycol < 7) { for(i=0; i<k; i++) for(j=0; j<n; j++) { tempB[i*n+j] = b[i*n+j]; } } MPI_Reduce(tempB, b, k*n, MPI_DOUBLE, MPI_SUM, 7, my_row_comm); } // printf("rows = %d, columns = %d\n",rows, columns); // printf("---step 3:myrow = %d, mycol = %d\n\n",myrow, mycol); for(round=0; round<nprow; round++) { // if(myrow == mycol) // printf("round = %d\n", round); // if(myrow == 5 || mycol == 5) roots = round; if(r_rank == roots) { for(i=0; i<m; i++) for(j=0; j<k; j++) { tempA[i*k+j] = a[i*k+j]; } } if(c_rank == roots) { for(i=0; i<k; i++) for(j=0; j<n; j++) { tempB[i*n+j] = b[i*n+j]; } } if(TIMER) t_bc = MPI_Wtime(); /* Broadcast to right */ if(PIPE) { MY_Bcast(tempA, m*k, MPI_DOUBLE, roots, my_row_comm, r_rank, columns, pk); } else { MPI_Bcast(tempA, k*m, MPI_DOUBLE, roots, my_row_comm); } // if(c_rank == 5) // printf("round = %d, :myrow = %d, mycol = %d\n\n", round, myrow, mycol); /* Broadcast below */ if(PIPE) { MY_Bcast(tempB, k*n, MPI_DOUBLE, roots, my_column_comm, c_rank, rows, pk); } else { MPI_Bcast(tempB, n*k, MPI_DOUBLE, roots, my_column_comm); } if(TIMER) { t_bc = MPI_Wtime() - t_bc; tt_bc += t_bc; t_calc = MPI_Wtime(); } if(DVFS_ENABLE) mapping(g_rank%rows, DVFS_HIGH); /* Do the multiplication */ dgemm_(TRANSA, TRANSB, &m, &n, &k, ALPHA, tempA, &m, tempB, &k, BETA, c, &m); if(DVFS_ENABLE) mapping(g_rank%rows, DVFS_LOW); if(TIMER) { t_calc = MPI_Wtime() - t_calc; tt_calc += t_calc; } } if(TIMER) { t_tot = MPI_Wtime() - t_tot; tt_tot += t_tot; MPI_Reduce(&tt_tot, &t_tot, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&tt_bc, &t_bc, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&tt_calc, &t_calc, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); if(g_rank == 0) printf("tot = %10.6f, bc = %10.6f, calc = %10.6f\n", t_tot, t_bc, t_calc); } // if(myrow==0 && mycol==0) // printf("myrow = %d, mycol = %d\n\n",myrow, mycol); // printf("Test0\n"); MPI_Barrier(MPI_COMM_WORLD); free(tempA); free(tempB); MPI_Comm_free(&my_row_comm); MPI_Comm_free(&my_column_comm); // printf("pdgemm done!\n"); return; }