void display_random_messages() { bip::managed_mapped_file mmf(bip::open_only, "data.map"); shared_blobs* table = mmf.find_or_construct<shared_blobs>("blob_table")(mmf.get_segment_manager()); LazyReaderFunction<SpecificMessage> load(table); for (int i = 0; i<10; ++i) { auto index = rand() % table->size(); std::cout << "Random blob #" << index << ": '" << load(index).contents << "'\n"; } }
/////// // for demo, create some data.map contens void create_datamap() { bip::file_mapping::remove("data.map"); bip::managed_mapped_file mmf(bip::open_or_create, "data.map", 1ul<<20); // even sparse file sizes limited on COLIRU shared_blobs* table = mmf.find_or_construct<shared_blobs>("blob_table")(mmf.get_segment_manager()); std::ifstream ifs("main.cpp"); std::string line; while (std::getline(ifs, line)) table->emplace_back(line.begin(), line.end(), mmf.get_segment_manager()); std::cout << "Created blob table consisting of " << table->size() << " blobs\n"; }
bool Predictor::Store(std::ostream& os) { ModelManagerFactory mmf(ModelManager::PARAMFILE); ModelManager* pModelManager = mmf.Make(); if(!pModelManager) { TERR("unable to make ModelManager."); return false; } bool bRet = pModelManager->Store(mpTreeBoost, os); if(pModelManager) delete pModelManager; return bRet; }
int main(int argc, char** argv) { char* filename = argv[1]; mlog.verbosity = 4; if (argc >= 3) sscanf(argv[2], "%d", &mlog.verbosity); cout << mlog.verbosity << endl; Bifstream ifs(filename); MMF mmf(ifs); BlockedCmatrix R = mmf.reconstruction(); Bstructure rstruct = mmf.stage[0]->remap->sourceStructure(); BlockedMatrix<BLOCK> M = BlockedMatrix<BLOCK>::RandomSymmetric(rstruct); }
void LoadSpells(SharedDatabase *database) { EQEmu::IPCMutex mutex("spells"); mutex.Lock(); int records = database->GetMaxSpellID() + 1; if(records == 0) { EQ_EXCEPT("Shared Memory", "Unable to get any spells from the database."); } uint32 size = records * sizeof(SPDat_Spell_Struct); EQEmu::MemoryMappedFile mmf("shared/spells", size); mmf.ZeroFile(); void *ptr = mmf.Get(); database->LoadSpells(ptr, records); mutex.Unlock(); }
void LoadFactions(SharedDatabase *database) { EQEmu::IPCMutex mutex("faction"); mutex.Lock(); uint32 lists = 0; uint32 max_list = 0; database->GetFactionListInfo(lists, max_list); uint32 size = static_cast<uint32>(EQEmu::FixedMemoryHashSet<NPCFactionList>::estimated_size(lists, max_list)); EQEmu::MemoryMappedFile mmf("shared/faction", size); mmf.ZeroFile(); void *ptr = mmf.Get(); database->LoadNPCFactionLists(ptr, size, lists, max_list); mutex.Unlock(); }
void LoadBaseData(SharedDatabase *database) { EQEmu::IPCMutex mutex("base_data"); mutex.Lock(); int records = (database->GetMaxBaseDataLevel() + 1); if(records == 0) { EQ_EXCEPT("Shared Memory", "Unable to get base data from the database."); } uint32 size = records * 16 * sizeof(BaseDataStruct); EQEmu::MemoryMappedFile mmf("shared/base_data", size); mmf.ZeroFile(); void *ptr = mmf.Get(); database->LoadBaseData(ptr, records); mutex.Unlock(); }
void LoadSkillCaps(SharedDatabase *database, const std::string &prefix) { EQEmu::IPCMutex mutex("skill_caps"); mutex.Lock(); uint32 class_count = PLAYER_CLASS_COUNT; uint32 skill_count = EQEmu::skills::HIGHEST_SKILL + 1; uint32 level_count = HARD_LEVEL_CAP + 1; uint32 size = (class_count * skill_count * level_count * sizeof(uint16)); auto Config = EQEmuConfig::get(); std::string file_name = Config->SharedMemDir + prefix + std::string("skill_caps"); EQEmu::MemoryMappedFile mmf(file_name, size); mmf.ZeroFile(); void *ptr = mmf.Get(); database->LoadSkillCaps(ptr); mutex.Unlock(); }
void LoadItems(SharedDatabase *database) { EQEmu::IPCMutex mutex("items"); mutex.Lock(); int32 items = -1; uint32 max_item = 0; database->GetItemsCount(items, max_item); if(items == -1) { EQ_EXCEPT("Shared Memory", "Unable to get any items from the database."); } uint32 size = static_cast<uint32>(EQEmu::FixedMemoryHashSet<Item_Struct>::estimated_size(items, max_item)); EQEmu::MemoryMappedFile mmf("shared/items", size); mmf.ZeroFile(); void *ptr = mmf.Get(); database->LoadItems(ptr, size, items, max_item); mutex.Unlock(); }
int main(int argc, char** argv) { int n = 10; if (argc >= 2) sscanf(argv[1], "%d", &n); int nclusters = 1; if (argc >= 3) sscanf(argv[2], "%d", &nclusters); MMFmatrix<BLOCK> A(n, Random()); cout << A << endl; mlog.verbosity = 0; MMF mmf(A, MMFparams::k(2).ndensestages(2).nsparsestages(2).nclusters( nclusters)); Rstream s(cout); mmf.graph(s); }
int read_mtx ( const char *fileName, idx *nv, idx *ne, idx **xadj, idx **adj, wt **ew, bool symmetrize = false, bool remove_diagonal = true, bool transpose = false){ std::ifstream mmf (fileName, std::ifstream::in); if (!mmf.is_open()) { throw std::runtime_error ("File cannot be opened\n"); } std::string fline = ""; getline(mmf, fline); if (fline.size() < 2 || fline[0] != '%' || fline[1] != '%'){ throw std::runtime_error ("Invalid MM file. Line-1\n"); } int mtx_object = 0; // 0- matrix, 1-vector int mtx_format = 0; // 0- coordinate; 1- array //int mtx_field = 0; //0-real, 1-double, 2-complex, 3- integer, 4-pattern int mtx_sym = 0; //0-general, 1-symmetric, 2-skew-symmetric, 3-hermitian if (fline.find("matrix") != std::string::npos){ mtx_object = 0; } else if (fline.find("vector") != std::string::npos){ mtx_object = 1; } if (fline.find("coordinate") != std::string::npos){ mtx_format = 0; } else if (fline.find("array") == std::string::npos){ mtx_format = 1; } if (fline.find("real") != std::string::npos){ //mtx_field = 0; } else if (fline.find("double") != std::string::npos){ //mtx_field = 1; } else if (fline.find("complex") != std::string::npos){ //mtx_field = 2; } else if (fline.find("integer") != std::string::npos){ //mtx_field = 3; } else if (fline.find("pattern") != std::string::npos){ //mtx_field = 4; } if (fline.find("skew-symmetric") != std::string::npos){ mtx_sym = 2; } else if (fline.find("symmetric") != std::string::npos){ mtx_sym = 1; } else if (fline.find("hermitian") != std::string::npos){ mtx_sym = 3; } else if (fline.find("general") != std::string::npos){ mtx_sym = 0; } if (mtx_object == 1) { throw std::runtime_error ("VECTOR TYPE NOT HANDLED YET\n"); } if (mtx_format == 1) { throw std::runtime_error ("ARRAY TYPE NOT HANDLED YET\n"); } if (!symmetrize && (mtx_sym == 2 || mtx_sym == 3)) { throw std::runtime_error ("SKEW-SYMMETRIC and HERMITIAN TYPE NOT HANDLED YET\n"); } while(1){ getline(mmf, fline); if(fline[0] != '%') break; } std::stringstream ss (fline); idx nr = 0, nc = 0, nnz = 0; ss >> nr >> nc >> nnz; //if (nr != nc) {std::cerr << "NON-SQUARE MATRIX TYPE NOT HANDLED YET"<< std::endl; return (1); } idx noEdges = nnz; if (mtx_sym == 1 || symmetrize) noEdges = 2 * nnz; std::vector <struct Edge<idx, wt> > edges (noEdges); idx nE = 0, noDiagonal = 0; for (idx i = 0; i < nnz; ++i){ getline(mmf, fline); std::stringstream ss2 (fline); struct Edge<idx, wt> tmp; idx s,d; wt w; ss2 >> s >> d >> w; if (!transpose){ tmp.src = s - 1; tmp.dst = d - 1; tmp.ew = w; } else { tmp.src = d - 1; tmp.dst = s - 1; tmp.ew = w; } if (tmp.src == tmp.dst){ noDiagonal++; if (!remove_diagonal){ edges[nE++] = tmp; } continue; } edges[nE++] = tmp; if (mtx_sym == 1 || symmetrize){ struct Edge<idx, wt> tmp2; tmp2.src = tmp.dst; tmp2.dst = tmp.src; tmp2.ew = tmp.ew; edges[nE++] = tmp2; } } mmf.close(); std::sort (edges.begin(), edges.begin() + nE); if (transpose){ idx tmp = nr; nr = nc; nc = tmp; } //idx *nv, idx *ne, idx **xadj, idx **adj, wt **wt *nv = nr; *ne = nE; //*xadj = new idx[nr + 1]; md_malloc<idx>(xadj, nr+1); //*adj = new idx[nE]; md_malloc<idx>(adj, nE); //*ew = new wt[nE]; md_malloc<wt>(ew, nE); idx eind = 0; idx actual = 0; for (idx i = 0; i < nr; ++i){ (*xadj)[i] = actual; bool is_first = true; while (edges[eind].src == i){ if (is_first || !symmetrize || eind == 0 || (eind > 0 && edges[eind - 1].dst != edges[eind].dst)){ (*adj)[actual] = edges[eind].dst; (*ew)[actual] = edges[eind].ew; ++actual; } is_first = false; ++eind; } } (*xadj)[nr] = actual; *ne = actual; return 0; }