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;
}
