Beispiel #1
0
Datei: bsq.c Projekt: dubus-b/BSQ
int		main(int argc, char **argv)
{
  t_info_array	board;
  t_pos_square	result;
  char		*file;
  char		*line_file;
  char		*map;

  board.nb_line = 0;
  board.nb_col = 0;
  board.array = NULL;
  if (argc == 1)
    my_putstr("Usage: ./bsq [FILE] ");
  file = fd(argv);
  line_file = line(file);
  board.nb_line = my_getnbr(line_file);
  free(line_file);
  map = maps(file);
  board.nb_col = my_col_nbr(map);
  board.array = get_array(map, board.nb_line, board.nb_col, 0);
  algo(&board, &result, 0, 0);
  modif_map(&board, &result);
  my_putchar_et(&board);
  free(file);
  return (0);
}
// Create a maps file that is extremely large.
TEST(MapsTest, large_file) {
  TemporaryFile tf;
  ASSERT_TRUE(tf.fd != -1);

  std::string file_data;
  uint64_t start = 0x700000;
  for (size_t i = 0; i < 5000; i++) {
    file_data +=
        android::base::StringPrintf("%" PRIx64 "-%" PRIx64 " r-xp 1000 00:0 0 /fake%zu.so\n",
                                    start + i * 4096, start + (i + 1) * 4096, i);
  }

  ASSERT_TRUE(android::base::WriteStringToFile(file_data, tf.path, 0660, getuid(), getgid()));

  FileMaps maps(tf.path);

  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(5000U, maps.Total());
  for (size_t i = 0; i < 5000; i++) {
    MapInfo* info = maps.Get(i);
    ASSERT_EQ(start + i * 4096, info->start) << "Failed at map " + std::to_string(i);
    ASSERT_EQ(start + (i + 1) * 4096, info->end) << "Failed at map " + std::to_string(i);
    std::string name = "/fake" + std::to_string(i) + ".so";
    ASSERT_EQ(name, info->name) << "Failed at map " + std::to_string(i);
  }
}
TEST(MapsTest, file_no_map_name) {
  TemporaryFile tf;
  ASSERT_TRUE(tf.fd != -1);

  ASSERT_TRUE(
      android::base::WriteStringToFile("7b29b000-7b29e000 r-xp a0000000 00:00 0\n"
                                       "7b2b0000-7b2e0000 r-xp b0000000 00:00 0   /fake2.so\n"
                                       "7b2e0000-7b2f0000 r-xp c0000000 00:00 0 \n",
                                       tf.path, 0660, getuid(), getgid()));

  FileMaps maps(tf.path);

  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(3U, maps.Total());
  auto it = maps.begin();
  ASSERT_EQ(0x7b29b000U, it->start);
  ASSERT_EQ(0x7b29e000U, it->end);
  ASSERT_EQ(0xa0000000U, it->offset);
  ASSERT_EQ(PROT_READ | PROT_EXEC, it->flags);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(0x7b2b0000U, it->start);
  ASSERT_EQ(0x7b2e0000U, it->end);
  ASSERT_EQ(0xb0000000U, it->offset);
  ASSERT_EQ(PROT_READ | PROT_EXEC, it->flags);
  ASSERT_EQ("/fake2.so", it->name);
  ++it;
  ASSERT_EQ(0x7b2e0000U, it->start);
  ASSERT_EQ(0x7b2f0000U, it->end);
  ASSERT_EQ(0xc0000000U, it->offset);
  ASSERT_EQ(PROT_READ | PROT_EXEC, it->flags);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(it, maps.end());
}
TEST(MapsTest, parse_name) {
  BufferMaps maps(
      "7b29b000-7b29e000 rw-p 00000000 00:00 0\n"
      "7b29e000-7b29f000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
      "7b29f000-7b2a0000 rw-p 00000000 00:00 0");

  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(3U, maps.Total());
  auto it = maps.begin();
  ASSERT_EQ("", it->name);
  ASSERT_EQ(0x7b29b000U, it->start);
  ASSERT_EQ(0x7b29e000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
  ++it;
  ASSERT_EQ("/system/lib/fake.so", it->name);
  ASSERT_EQ(0x7b29e000U, it->start);
  ASSERT_EQ(0x7b29f000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
  ++it;
  ASSERT_EQ("", it->name);
  ASSERT_EQ(0x7b29f000U, it->start);
  ASSERT_EQ(0x7b2a0000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
  ++it;
  ASSERT_EQ(it, maps.end());
}
Beispiel #5
0
void init_maps()
{
    if (g_stack_max != 0){
        return;
    }

    maps();
}
TEST(MapsTest, find) {
  BufferMaps maps(
      "1000-2000 r--p 00000010 00:00 0 /system/lib/fake1.so\n"
      "3000-4000 -w-p 00000020 00:00 0 /system/lib/fake2.so\n"
      "6000-8000 --xp 00000030 00:00 0 /system/lib/fake3.so\n"
      "a000-b000 rw-p 00000040 00:00 0 /system/lib/fake4.so\n"
      "e000-f000 rwxp 00000050 00:00 0 /system/lib/fake5.so\n");
  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(5U, maps.Total());

  ASSERT_TRUE(maps.Find(0x500) == nullptr);
  ASSERT_TRUE(maps.Find(0x2000) == nullptr);
  ASSERT_TRUE(maps.Find(0x5010) == nullptr);
  ASSERT_TRUE(maps.Find(0x9a00) == nullptr);
  ASSERT_TRUE(maps.Find(0xf000) == nullptr);
  ASSERT_TRUE(maps.Find(0xf010) == nullptr);

  MapInfo* info = maps.Find(0x1000);
  ASSERT_TRUE(info != nullptr);
  ASSERT_EQ(0x1000U, info->start);
  ASSERT_EQ(0x2000U, info->end);
  ASSERT_EQ(0x10U, info->offset);
  ASSERT_EQ(PROT_READ, info->flags);
  ASSERT_EQ("/system/lib/fake1.so", info->name);

  info = maps.Find(0x3020);
  ASSERT_TRUE(info != nullptr);
  ASSERT_EQ(0x3000U, info->start);
  ASSERT_EQ(0x4000U, info->end);
  ASSERT_EQ(0x20U, info->offset);
  ASSERT_EQ(PROT_WRITE, info->flags);
  ASSERT_EQ("/system/lib/fake2.so", info->name);

  info = maps.Find(0x6020);
  ASSERT_TRUE(info != nullptr);
  ASSERT_EQ(0x6000U, info->start);
  ASSERT_EQ(0x8000U, info->end);
  ASSERT_EQ(0x30U, info->offset);
  ASSERT_EQ(PROT_EXEC, info->flags);
  ASSERT_EQ("/system/lib/fake3.so", info->name);

  info = maps.Find(0xafff);
  ASSERT_TRUE(info != nullptr);
  ASSERT_EQ(0xa000U, info->start);
  ASSERT_EQ(0xb000U, info->end);
  ASSERT_EQ(0x40U, info->offset);
  ASSERT_EQ(PROT_READ | PROT_WRITE, info->flags);
  ASSERT_EQ("/system/lib/fake4.so", info->name);

  info = maps.Find(0xe500);
  ASSERT_TRUE(info != nullptr);
  ASSERT_EQ(0xe000U, info->start);
  ASSERT_EQ(0xf000U, info->end);
  ASSERT_EQ(0x50U, info->offset);
  ASSERT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags);
  ASSERT_EQ("/system/lib/fake5.so", info->name);
}
static void VerifyLine(std::string line, MapInfo* info) {
  BufferMaps maps(line.c_str());

  if (info == nullptr) {
    ASSERT_FALSE(maps.Parse()) << "Failed on: " + line;
  } else {
    ASSERT_TRUE(maps.Parse()) << "Failed on: " + line;
    MapInfo* element = maps.Get(0);
    ASSERT_TRUE(element != nullptr) << "Failed on: " + line;
    *info = *element;
  }
}
TEST(MapsTest, file_should_fail) {
  TemporaryFile tf;
  ASSERT_TRUE(tf.fd != -1);

  ASSERT_TRUE(android::base::WriteStringToFile(
      "7ffff7dda000-7ffff7dfd7ffff7ff3000-7ffff7ff4000 ---p 0000f000 fc:02 44171565\n", tf.path,
      0660, getuid(), getgid()));

  FileMaps maps(tf.path);

  ASSERT_FALSE(maps.Parse());
}
Beispiel #9
0
void MapDatabase::LoadMap(const wxInt32 index, Map &map)
{
	wxASSERT(sOffsets.size() > (wxUint32) index);

	wxFileInputStream x(FilePath::Data(DataFileMaps));
	wxDataInputStream maps(x);

	//seek to this position in the game file
	x.SeekI(sOffsets[index]);

	map.load(maps);
}
Beispiel #10
0
void YOGLoginScreen::runLobby()
{
	Glob2TabScreen screen(true);
	YOGClientLobbyScreen lobby(&screen, client);
	YOGClientOptionsScreen options(&screen, client);
	YOGClientMapDownloadScreen maps(&screen, client);
	int rc = screen.execute(globalContainer->gfx, 40);
	if(rc == YOGClientLobbyScreen::ConnectionLost)
		endExecute(ConnectionLost);
	else if(rc == -1)
		endExecute(-1);
	else
		endExecute(LoggedIn);
}
Beispiel #11
0
void HlpFlightPlannerApp::setLayerSet( bool updateExtent )
{
  QList<QgsMapCanvasLayer> layers;
  layers.append( QgsMapCanvasLayer( mFlightlineLayer, true ) );
  layers.append( QgsMapCanvasLayer( mWaypointLayer, true ) );
  layers.append( QgsMapCanvasLayer( mProfileLayer, true ) );
  // reverse order of legend
  QListIterator<QgsMapCanvasLayer> maps( HlpMapRegistry::instance()->layers() );
  maps.toBack();
  while ( maps.hasPrevious() )
    layers.append( maps.previous() );
  mMapCanvas->setLayerSet( layers );
  if ( updateExtent )
    mMapCanvas->zoomToFullExtent();
}
Beispiel #12
0
void MapLoader::load(unsigned int width, const QString &theme, unsigned int height, float opacity)
{
  // find the maps available
  QValueList<uint> sizes;
  QStringList files = maps(theme);
  for (uint i=0; i<files.count(); ++i)
    {
      QString f = files[i];
      int pos = f.findRev("/");
      if (pos >= 0)
        f = f.mid(pos+1);
      pos = f.findRev(".");
      if (pos >= 0)
        f = f.left(pos);
      sizes.append(f.toInt());
    }
  qHeapSort(sizes);

  // find the closest (bigger) size
  uint size=0;
  for (uint i=0; i<sizes.count(); ++i)
    if (sizes[i] >= width)
      {
	size = sizes[i];
	break;
      }
  
  QImage image;
  if (size == 0)
    {
      image = QImage(locate("data", "kworldclock/maps/depths/800.jpg"));
      size = 800;
    }
  else  
    image = QImage(locate("data", QString("kworldclock/maps/%1/%2.jpg").arg(theme).arg(size)));

  if (height == 0)
    height = width/2;

  if ((image.width() != (int)width) || (image.height() != (int)height))
    image = image.smoothScale(width, height);

  // convert to light map
  _light.convertFromImage(image);

  // calculate dark map
  _dark.convertFromImage(KImageEffect::blend(Qt::black, image, opacity));
}
cv::Mat HogIntegralImageComputer::create_hog_maps(const cv::Mat &mags, const cv::Mat &qangles)
{
    cv::Mat maps(mags.rows, mags.cols, CV_32FC(9), cv::Scalar(0.0f));
    for (int i = 0; i < mags.rows; i++) {
        for (int j = 0; j < mags.cols; j++) {
            cv::Vec2b ang = qangles.at<cv::Vec2b>(i,j);
            cv::Vec2f mag = mags.at<cv::Vec2f>(i,j);
            cv::VecHogf v(0.0f);
            v[ang[0]] += mag[0];
            v[ang[1]] += mag[1];
            v[CC_HOG_CHANS] = mag[0] + mag[1]; // gradient magnitude...
            maps.at<cv::VecHogf>(i,j) = v;
        }
    }
    return maps;
}
    bool isIsomorphic(string s, string t) {

        int len = s.size();
        vector<int> maps(300, -1);
        vector<int> mapt(300, -1);
        for (int i = 0; i < len; ++i) {
            int idt = t[i];
            int ids = s[i];
            if ((maps[ids] == -1 || maps[ids] == idt) && (mapt[idt] == -1 || mapt[idt] == ids)) {
                maps[ids] = idt;
                mapt[idt] = ids;
            } else {
                return false;
            }
        }

        return true;
    }
TEST(MapsTest, parse_permissions) {
  BufferMaps maps(
      "1000-2000 ---s 00000000 00:00 0\n"
      "2000-3000 r--s 00000000 00:00 0\n"
      "3000-4000 -w-s 00000000 00:00 0\n"
      "4000-5000 --xp 00000000 00:00 0\n"
      "5000-6000 rwxp 00000000 00:00 0\n");

  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(5U, maps.Total());
  auto it = maps.begin();
  ASSERT_EQ(PROT_NONE, it->flags);
  ASSERT_EQ(0x1000U, it->start);
  ASSERT_EQ(0x2000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(PROT_READ, it->flags);
  ASSERT_EQ(0x2000U, it->start);
  ASSERT_EQ(0x3000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(PROT_WRITE, it->flags);
  ASSERT_EQ(0x3000U, it->start);
  ASSERT_EQ(0x4000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(PROT_EXEC, it->flags);
  ASSERT_EQ(0x4000U, it->start);
  ASSERT_EQ(0x5000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, it->flags);
  ASSERT_EQ(0x5000U, it->start);
  ASSERT_EQ(0x6000U, it->end);
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ("", it->name);
  ++it;
  ASSERT_EQ(it, maps.end());
}
Beispiel #16
0
TMXTiledMap* MapLayer::initMapWithFile(const char *name)
{
	TMXTiledMap *tileMap;

	std::string path;
	std::string maps("Maps");
	auto iterFind = std::find(searchPaths.begin(), searchPaths.end(), maps);
	if (iterFind == searchPaths.end())
		CCAssert(iterFind != searchPaths.end(), "Maps in vector searchPaths not for");
	else
	{
		path = maps + '/' + name;
		tileMap = TMXTiledMap::create(path);
		CCAssert(tileMap != nullptr, "tileMap == NULL");
		tileMap->setPosition(Vec2(0, 0));
		this->addChild(tileMap);
	}
	global->tileMap = tileMap;
	return tileMap;
}
Beispiel #17
0
void stats(std:: valarray<float> map, float &mean, float &sigma, float &kurt, float &skew) {
    float sum = map.sum();
    int n = map.size();
    mean = map.sum()/float(n);
    std:: valarray <float> maps(n);
    valarray<float> maps2(n),maps3(n),maps4(n);
    for(int i=0; i<n; i++) {
        maps2[i] = gsl_pow_2(map[i] - mean);
        maps3[i] = gsl_pow_3(map[i] - mean);
        maps4[i] = gsl_pow_4(map[i] - mean);
    }
    sum = maps2.sum();
    sigma = sqrt(sum/(float(n)-1.));
    sum = maps3.sum();
    double mu3 = sum/(float(n)-1.);
    sum = maps4.sum();
    double mu4 = sum/(float(n)-1.);
    kurt = mu4/gsl_pow_4(sigma) -3;
    skew = mu3/gsl_pow_3(sigma);
}
Beispiel #18
0
void interpret(char* str)
{
	vector<string> strs;
	string line(str);
	boost::split(strs,line,boost::is_any_of(" "));
	if(strs[0]=="open")
	{
		if(boost::starts_with(strs[1],"http://") || boost::starts_with(strs[1],"www") || boost::ends_with(strs[1],".com"))
			urlopen(strs[1].c_str());
		else
			fileopen((char*)strs[1].c_str());
	}else if(strs[0]=="search")
	{
		string term(strs[1]);
		for(int i=2;i<strs.size();i++)
		{
			term+=string(" ");
			term+=string(strs[i]);
		}
		websearch(term.c_str());
	}else if(strs[0]=="drive")
	{
		std::string s = string(str);
		std::string delimiter = " from ";
		std::string from,to;
		size_t pos = 0;
		std::string token;
		pos = s.find(delimiter);
    	token = s.substr(0, pos);
    	std::cout << token << std::endl;
    	s.erase(0, pos + delimiter.length());
		
		delimiter=" to ";
		while ((pos = s.find(delimiter)) != std::string::npos) {
    		from = s.substr(0, pos);
    		s.erase(0, pos + delimiter.length());
		}
		to=s;
		maps(from.c_str(),to.c_str());
	}
}
TEST(MapsTest, device) {
  BufferMaps maps(
      "a000-e000 rw-p 00000000 00:00 0 /dev/\n"
      "f000-f100 rw-p 00000000 00:00 0 /dev/does_not_exist\n"
      "f100-f200 rw-p 00000000 00:00 0 /dev/ashmem/does_not_exist\n"
      "f200-f300 rw-p 00000000 00:00 0 /devsomething/does_not_exist\n");

  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(4U, maps.Total());
  auto it = maps.begin();
  ASSERT_TRUE(it->flags & 0x8000);
  ASSERT_EQ("/dev/", it->name);
  ++it;
  ASSERT_TRUE(it->flags & 0x8000);
  ASSERT_EQ("/dev/does_not_exist", it->name);
  ++it;
  ASSERT_FALSE(it->flags & 0x8000);
  ASSERT_EQ("/dev/ashmem/does_not_exist", it->name);
  ++it;
  ASSERT_FALSE(it->flags & 0x8000);
  ASSERT_EQ("/devsomething/does_not_exist", it->name);
}
TEST(MapsTest, parse_offset) {
  BufferMaps maps(
      "a000-e000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
      "e000-f000 rw-p 00a12345 00:00 0 /system/lib/fake.so\n");

  ASSERT_TRUE(maps.Parse());
  ASSERT_EQ(2U, maps.Total());
  auto it = maps.begin();
  ASSERT_EQ(0U, it->offset);
  ASSERT_EQ(0xa000U, it->start);
  ASSERT_EQ(0xe000U, it->end);
  ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
  ASSERT_EQ("/system/lib/fake.so", it->name);
  ++it;
  ASSERT_EQ(0xa12345U, it->offset);
  ASSERT_EQ(0xe000U, it->start);
  ASSERT_EQ(0xf000U, it->end);
  ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
  ASSERT_EQ("/system/lib/fake.so", it->name);
  ++it;
  ASSERT_EQ(maps.end(), it);
}
Beispiel #21
0
bool extractPythonLibrary()
{
#if defined(HAVE_DLADDR)
    // Add the library into the path in case it has a .zip file appended
    Dl_info info;
    memset(&info, 0, sizeof(info));
    int res = dladdr((void *)&extractPythonLibrary, &info);
    if (!res) {
        qWarning() << "Could not determine library path";
        return false;
    }

    QString fname = QString::fromUtf8(info.dli_fname);
    qDebug() << "Got library name: " << fname;
    // On Android, dladdr() returns only the basename of the file, so we go
    // hunt for the full path in /proc/self/maps, where the shared library is
    // mapped (TODO: We could parse the address range and compare that, too)
    if (!fname.startsWith("/")) {
        QFile mapsf("/proc/self/maps");
        if (mapsf.exists()) {
            mapsf.open(QIODevice::ReadOnly);
            QTextStream maps(&mapsf);
            QString line;
            while (!(line = maps.readLine()).isNull()) {
                QString filename = line.split(' ', QString::SkipEmptyParts).last();
                if (filename.endsWith("/" + fname)) {
                    fname = filename;
                    qDebug() << "Resolved full path:" << fname;
                    break;
                }
            }
        }
    }
    prependPythonPath(fname);
#endif
    return true;
}
Beispiel #22
0
void CObjectThread::run()
{
	CTimer cleanup(10 * SECOND);
	CTimer maps(100);
	while(!this->shutting_down)
	{
		if(cleanup.Passed())
		{
			this->rwl->lockForRead();
			CObjectManager::MapType::iterator itr;
			for(itr = this->mang->container.begin(); itr != this->mang->container.end(); true)
			{
				CObjectManager::MapType::iterator current = itr;
				++itr;
				CObject * object = current->second;
				if(object && object->type < OBJECT_EMPTY)
				{
					this->rwl->lockForWrite();
					switch(object->type)
					{
					case VOID_PLAYER:
						{
							CPlayer * player = (CPlayer*)object;
							delete player;
							break;
						}
					case VOID_UNIT:
						{
							CUnit * unit = (CUnit*)object;
							delete unit;
							break;
						}
					case VOID_EMPTY:
						{
							break;
						}
					case VOID_BOT:
						{
							CBot * bot = (CBot*)object;
							delete bot;
							break;
						}
					}
					this->mang->container.erase(current);
					this->rwl->unlock();
				}
			}
			this->rwl->unlock();
		}
		if(maps.Passed())
		{
			for(uint32 i = 0; i < MAX_MAPS; ++i)
			{
				this->map[i]->guids.clear();
			}
			this->rwl->lockForRead();
			CObjectManager::MapType::iterator itr;
			for(itr = this->mang->container.begin(); itr != this->mang->container.end(); true)
			{
				CObjectManager::MapType::iterator current = itr;
				++itr;
				CObject * object = current->second;
				if(object && (object->map >= 0 && object->map < MAX_MAPS) && object->type > OBJECT_EMPTY)
				{
					this->map[object->map]->guids.push_back(object->guid);
				}
			}
			this->rwl->unlock();
			init_genrand(GetTicks());
			for(uint32 i = 0; i < MAX_MAPS; ++i)
			{
				CWorldMap * pmap = this->map[i];
				for(uint32 i = 0; i < pmap->guids.size(); ++i)
				{
					if(pmap->guids.at(i).lo == 0)
					{
						uint32 count = 0;
						while(count < RETRIES)
						{
							++count;
							GUID_LOW lo = uint32(genrand_int32()) % MAX_GUID;
							bool found = false;
							for(uint32 k = 0; k < pmap->guids.size(); ++k)
							{
								if(pmap->guids.at(k).lo == lo)
								{
									found = true;
									break;
								}
							}
							if(!found)
							{
								this->mang->FindHigh(pmap->guids.at(i).hi)->guid.lo = lo;
								pmap->guids.at(i).lo = lo;
								break;
							}
						}
						assert(count != RETRIES);
					}
				}
				pmap->UpdateMap();
			}
		}
	}
	this->msleep(DEFSLEEP);
}
int main(int argc, char* argv[]) {
    int opt;
    auto pss_sort = [](const Vma& a, const Vma& b) {
        uint64_t pss_a = a.usage.pss;
        uint64_t pss_b = b.usage.pss;
        return pss_a > pss_b;
    };

    auto uss_sort = [](const Vma& a, const Vma& b) {
        uint64_t uss_a = a.usage.uss;
        uint64_t uss_b = b.usage.uss;
        return uss_a > uss_b;
    };

    std::function<bool(const Vma& a, const Vma& b)> sort_func = nullptr;
    while ((opt = getopt(argc, argv, "himpuWw")) != -1) {
        switch (opt) {
            case 'h':
                hide_zeroes = true;
                break;
            case 'i':
                // TODO: libmeminfo doesn't support the flag to chose
                // between idle page tracking vs clear_refs. So for now,
                // this flag is unused and the library defaults to using
                // /proc/<pid>/clear_refs for finding the working set.
                use_pageidle = true;
                break;
            case 'm':
                // this is the default
                break;
            case 'p':
                sort_func = pss_sort;
                break;
            case 'u':
                sort_func = uss_sort;
                break;
            case 'W':
                reset_wss = true;
                break;
            case 'w':
                show_wss = true;
                break;
            case '?':
                usage(EXIT_SUCCESS);
            default:
                usage(EXIT_FAILURE);
        }
    }

    if (optind != (argc - 1)) {
        fprintf(stderr, "Need exactly one pid at the end\n");
        usage(EXIT_FAILURE);
    }

    pid_t pid = atoi(argv[optind]);
    if (pid == 0) {
        std::cerr << "Invalid process id" << std::endl;
        exit(EXIT_FAILURE);
    }

    if (reset_wss) {
        if (!ProcMemInfo::ResetWorkingSet(pid)) {
            std::cerr << "Failed to reset working set of pid : " << pid << std::endl;
            exit(EXIT_FAILURE);
        }
        return 0;
    }

    ProcMemInfo proc(pid, show_wss);
    const MemUsage& proc_stats = proc.Usage();
    std::vector<Vma> maps(proc.Maps());
    if (sort_func != nullptr) {
        std::sort(maps.begin(), maps.end(), sort_func);
    }

    return show(proc_stats, maps);
}
int main(int argc, char ** argv)
{
	size_t n = atoi(argv[1]);
	size_t num_threads = atoi(argv[2]);
	size_t method = argc <= 3 ? 0 : atoi(argv[3]);

	std::cerr << std::fixed << std::setprecision(2);

	ThreadPool pool(num_threads);

	Source data(n);

	{
		Stopwatch watch;
		DB::ReadBufferFromFileDescriptor in1(STDIN_FILENO);
		DB::CompressedReadBuffer in2(in1);

		in2.readStrict(reinterpret_cast<char*>(&data[0]), sizeof(data[0]) * n);

		watch.stop();
		std::cerr << std::fixed << std::setprecision(2)
			<< "Vector. Size: " << n
			<< ", elapsed: " << watch.elapsedSeconds()
			<< " (" << n / watch.elapsedSeconds() << " elem/sec.)"
			<< std::endl << std::endl;
	}

	if (!method || method == 1)
	{
		/** Вариант 1.
		  * В разных потоках агрегируем независимо в разные хэш-таблицы.
		  * Затем сливаем их вместе.
		  */

		std::vector<Map> maps(num_threads);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate1,
				std::ref(maps[i]),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
			<< "Aggregated in " << time_aggregated
			<< " (" << n / time_aggregated << " elem/sec.)"
			<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes: ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << maps[i].size();
			size_before_merge += maps[i].size();
		}
		std::cerr << std::endl;

		watch.restart();

		for (size_t i = 1; i < num_threads; ++i)
			for (auto it = maps[i].begin(); it != maps[i].end(); ++it)
				maps[0][it->first] += it->second;

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
			<< "Merged in " << time_merged
			<< " (" << size_before_merge / time_merged << " elem/sec.)"
			<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
			<< "Total in " << time_total
			<< " (" << n / time_total << " elem/sec.)"
			<< std::endl;
		std::cerr << "Size: " << maps[0].size() << std::endl << std::endl;
	}

	if (!method || method == 12)
	{
		/** То же самое, но с оптимизацией для подряд идущих одинаковых значений.
		  */

		std::vector<Map> maps(num_threads);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate12,
									std::ref(maps[i]),
									data.begin() + (data.size() * i) / num_threads,
									data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
		<< "Aggregated in " << time_aggregated
		<< " (" << n / time_aggregated << " elem/sec.)"
		<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes: ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << maps[i].size();
			size_before_merge += maps[i].size();
		}
		std::cerr << std::endl;

		watch.restart();

		for (size_t i = 1; i < num_threads; ++i)
			for (auto it = maps[i].begin(); it != maps[i].end(); ++it)
				maps[0][it->first] += it->second;

		watch.stop();

		double time_merged = watch.elapsedSeconds();
		std::cerr
		<< "Merged in " << time_merged
		<< " (" << size_before_merge / time_merged << " elem/sec.)"
		<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
		<< "Total in " << time_total
		<< " (" << n / time_total << " elem/sec.)"
		<< std::endl;
		std::cerr << "Size: " << maps[0].size() << std::endl << std::endl;
	}

	if (!method || method == 11)
	{
		/** Вариант 11.
		  * То же, что вариант 1, но при мердже, изменён порядок циклов,
		  *  что потенциально может дать лучшую кэш-локальность.
		  *
		  * На практике, разницы нет.
		  */

		std::vector<Map> maps(num_threads);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate1,
				std::ref(maps[i]),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
		<< "Aggregated in " << time_aggregated
		<< " (" << n / time_aggregated << " elem/sec.)"
		<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes: ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << maps[i].size();
			size_before_merge += maps[i].size();
		}
		std::cerr << std::endl;

		watch.restart();

		std::vector<Map::iterator> iterators(num_threads);
		for (size_t i = 1; i < num_threads; ++i)
			iterators[i] = maps[i].begin();

		while (true)
		{
			bool finish = true;
			for (size_t i = 1; i < num_threads; ++i)
			{
				if (iterators[i] == maps[i].end())
					continue;

				finish = false;
				maps[0][iterators[i]->first] += iterators[i]->second;
				++iterators[i];
			}

			if (finish)
				break;
		}

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
		<< "Merged in " << time_merged
		<< " (" << size_before_merge / time_merged << " elem/sec.)"
		<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
		<< "Total in " << time_total
		<< " (" << n / time_total << " elem/sec.)"
		<< std::endl;
		std::cerr << "Size: " << maps[0].size() << std::endl << std::endl;
	}

	if (!method || method == 2)
	{
		/** Вариант 2.
		  * В разных потоках агрегируем независимо в разные two-level хэш-таблицы.
		  * Затем сливаем их вместе, распараллелив по bucket-ам первого уровня.
		  * При использовании хэш-таблиц больших размеров (10 млн. элементов и больше),
		  *  и большого количества потоков (8-32), слияние является узким местом,
		  *  и преимущество в производительности достигает 4 раз.
		  */

		std::vector<MapTwoLevel> maps(num_threads);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate2,
				std::ref(maps[i]),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
			<< "Aggregated in " << time_aggregated
			<< " (" << n / time_aggregated << " elem/sec.)"
			<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes: ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << maps[i].size();
			size_before_merge += maps[i].size();
		}
		std::cerr << std::endl;

		watch.restart();

		for (size_t i = 0; i < MapTwoLevel::NUM_BUCKETS; ++i)
			pool.schedule(std::bind(merge2,
				&maps[0], num_threads, i));

		pool.wait();

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
			<< "Merged in " << time_merged
			<< " (" << size_before_merge / time_merged << " elem/sec.)"
			<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
			<< "Total in " << time_total
			<< " (" << n / time_total << " elem/sec.)"
			<< std::endl;

		std::cerr << "Size: " << maps[0].size() << std::endl << std::endl;
	}

	if (!method || method == 22)
	{
		std::vector<MapTwoLevel> maps(num_threads);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate22,
									std::ref(maps[i]),
									data.begin() + (data.size() * i) / num_threads,
									data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
		<< "Aggregated in " << time_aggregated
		<< " (" << n / time_aggregated << " elem/sec.)"
		<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes: ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << maps[i].size();
			size_before_merge += maps[i].size();
		}
		std::cerr << std::endl;

		watch.restart();

		for (size_t i = 0; i < MapTwoLevel::NUM_BUCKETS; ++i)
			pool.schedule(std::bind(merge2,
									&maps[0], num_threads, i));

		pool.wait();

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
		<< "Merged in " << time_merged
		<< " (" << size_before_merge / time_merged << " elem/sec.)"
		<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
		<< "Total in " << time_total
		<< " (" << n / time_total << " elem/sec.)"
		<< std::endl;

		std::cerr << "Size: " << maps[0].size() << std::endl << std::endl;
	}

	if (!method || method == 3)
	{
		/** Вариант 3.
		  * В разных потоках агрегируем независимо в разные хэш-таблицы,
		  *  пока их размер не станет достаточно большим.
		  * Если размер локальной хэш-таблицы большой, и в ней нет элемента,
		  *  то вставляем его в одну глобальную хэш-таблицу, защищённую mutex-ом,
		  *  а если mutex не удалось захватить, то вставляем в локальную.
		  * Затем сливаем все локальные хэш-таблицы в глобальную.
		  * Этот метод плохой - много contention-а.
		  */

		std::vector<Map> local_maps(num_threads);
		Map global_map;
		Mutex mutex;

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate3,
				std::ref(local_maps[i]),
				std::ref(global_map),
				std::ref(mutex),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
			<< "Aggregated in " << time_aggregated
			<< " (" << n / time_aggregated << " elem/sec.)"
			<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes (local): ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << local_maps[i].size();
			size_before_merge += local_maps[i].size();
		}
		std::cerr << std::endl;
		std::cerr << "Size (global): " << global_map.size() << std::endl;
		size_before_merge += global_map.size();

		watch.restart();

		for (size_t i = 0; i < num_threads; ++i)
			for (auto it = local_maps[i].begin(); it != local_maps[i].end(); ++it)
				global_map[it->first] += it->second;

		pool.wait();

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
			<< "Merged in " << time_merged
			<< " (" << size_before_merge / time_merged << " elem/sec.)"
			<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
			<< "Total in " << time_total
			<< " (" << n / time_total << " elem/sec.)"
			<< std::endl;

		std::cerr << "Size: " << global_map.size() << std::endl << std::endl;
	}

	if (!method || method == 33)
	{
		/** Вариант 33.
		 * В разных потоках агрегируем независимо в разные хэш-таблицы,
		 *  пока их размер не станет достаточно большим.
		 * Затем сбрасываем данные в глобальную хэш-таблицу, защищённую mutex-ом, и продолжаем.
		 */

		std::vector<Map> local_maps(num_threads);
		Map global_map;
		Mutex mutex;

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate33,
				std::ref(local_maps[i]),
				std::ref(global_map),
				std::ref(mutex),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
		<< "Aggregated in " << time_aggregated
		<< " (" << n / time_aggregated << " elem/sec.)"
		<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes (local): ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << local_maps[i].size();
			size_before_merge += local_maps[i].size();
		}
		std::cerr << std::endl;
		std::cerr << "Size (global): " << global_map.size() << std::endl;
		size_before_merge += global_map.size();

		watch.restart();

		for (size_t i = 0; i < num_threads; ++i)
			for (auto it = local_maps[i].begin(); it != local_maps[i].end(); ++it)
				global_map[it->first] += it->second;

		pool.wait();

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
		<< "Merged in " << time_merged
		<< " (" << size_before_merge / time_merged << " elem/sec.)"
		<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
		<< "Total in " << time_total
		<< " (" << n / time_total << " elem/sec.)"
		<< std::endl;

		std::cerr << "Size: " << global_map.size() << std::endl << std::endl;
	}

	if (!method || method == 4)
	{
		/** Вариант 4.
		  * В разных потоках агрегируем независимо в разные хэш-таблицы,
		  *  пока их размер не станет достаточно большим.
		  * Если размер локальной хэш-таблицы большой, и в ней нет элемента,
		  *  то вставляем его в одну из 256 глобальных хэш-таблиц, каждая из которых под своим mutex-ом.
		  * Затем сливаем все локальные хэш-таблицы в глобальную.
		  * Этот метод не такой уж плохой при большом количестве потоков, но хуже второго.
		  */

		std::vector<Map> local_maps(num_threads);
		MapTwoLevel global_map;
		std::vector<Mutex> mutexes(MapTwoLevel::NUM_BUCKETS);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate4,
				std::ref(local_maps[i]),
				std::ref(global_map),
				&mutexes[0],
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
			<< "Aggregated in " << time_aggregated
			<< " (" << n / time_aggregated << " elem/sec.)"
			<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes (local): ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << local_maps[i].size();
			size_before_merge += local_maps[i].size();
		}
		std::cerr << std::endl;

		size_t sum_size = global_map.size();
		std::cerr << "Size (global): " << sum_size << std::endl;
		size_before_merge += sum_size;

		watch.restart();

		for (size_t i = 0; i < num_threads; ++i)
			for (auto it = local_maps[i].begin(); it != local_maps[i].end(); ++it)
				global_map[it->first] += it->second;

		pool.wait();

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
			<< "Merged in " << time_merged
			<< " (" << size_before_merge / time_merged << " elem/sec.)"
			<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
			<< "Total in " << time_total
			<< " (" << n / time_total << " elem/sec.)"
			<< std::endl;

		std::cerr << "Size: " << global_map.size() << std::endl << std::endl;
	}

/*	if (!method || method == 5)
	{
	*/	/** Вариант 5.
		  * В разных потоках агрегируем независимо в разные хэш-таблицы,
		  *  пока их размер не станет достаточно большим.
		  * Если размер локальной хэш-таблицы большой, и в ней нет элемента,
		  *  то вставляем его в одну глобальную хэш-таблицу, содержащую маленькие защёлки в каждой ячейке,
		  *  а если защёлку не удалось захватить, то вставляем в локальную.
		  * Затем сливаем все локальные хэш-таблицы в глобальную.
		  */
/*
		Map local_maps[num_threads];
		MapSmallLocks global_map;

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate5,
				std::ref(local_maps[i]),
				std::ref(global_map),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
			<< "Aggregated in " << time_aggregated
			<< " (" << n / time_aggregated << " elem/sec.)"
			<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes (local): ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << local_maps[i].size();
			size_before_merge += local_maps[i].size();
		}
		std::cerr << std::endl;
		std::cerr << "Size (global): " << global_map.size() << std::endl;
		size_before_merge += global_map.size();

		watch.restart();

		for (size_t i = 0; i < num_threads; ++i)
			for (auto it = local_maps[i].begin(); it != local_maps[i].end(); ++it)
				global_map.insert(std::make_pair(it->first, 0)).first->second += it->second;

		pool.wait();

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
			<< "Merged in " << time_merged
			<< " (" << size_before_merge / time_merged << " elem/sec.)"
			<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
			<< "Total in " << time_total
			<< " (" << n / time_total << " elem/sec.)"
			<< std::endl;

		std::cerr << "Size: " << global_map.size() << std::endl << std::endl;
	}*/

	/*if (!method || method == 6)
	{
		*//** Вариант 6.
		  * В разных потоках агрегируем независимо в разные хэш-таблицы.
		  * Затем "сливаем" их, проходя по ним в одинаковом порядке ключей.
		  * Довольно тормозной вариант.
		  */
/*
		std::vector<Map> maps(num_threads);

		Stopwatch watch;

		for (size_t i = 0; i < num_threads; ++i)
			pool.schedule(std::bind(aggregate1,
				std::ref(maps[i]),
				data.begin() + (data.size() * i) / num_threads,
				data.begin() + (data.size() * (i + 1)) / num_threads));

		pool.wait();

		watch.stop();
		double time_aggregated = watch.elapsedSeconds();
		std::cerr
			<< "Aggregated in " << time_aggregated
			<< " (" << n / time_aggregated << " elem/sec.)"
			<< std::endl;

		size_t size_before_merge = 0;
		std::cerr << "Sizes: ";
		for (size_t i = 0; i < num_threads; ++i)
		{
			std::cerr << (i == 0 ? "" : ", ") << maps[i].size();
			size_before_merge += maps[i].size();
		}
		std::cerr << std::endl;

		watch.restart();

		using Maps = std::vector<Map *>;
		Maps maps_to_merge(num_threads);
		for (size_t i = 0; i < num_threads; ++i)
			maps_to_merge[i] = &maps[i];

		size_t size = 0;

		for (size_t i = 0; i < 100; ++i)
		processMergedHashTables(maps_to_merge,
			[] (Map::value_type & dst, const Map::value_type & src) { dst.second += src.second; },
			[&] (const Map::value_type & dst) { ++size; });

		watch.stop();
		double time_merged = watch.elapsedSeconds();
		std::cerr
			<< "Merged in " << time_merged
			<< " (" << size_before_merge / time_merged << " elem/sec.)"
			<< std::endl;

		double time_total = time_aggregated + time_merged;
		std::cerr
			<< "Total in " << time_total
			<< " (" << n / time_total << " elem/sec.)"
			<< std::endl;
		std::cerr << "Size: " << size << std::endl << std::endl;
	}*/

	return 0;
}
Beispiel #25
0
//--------------|---------------------------------------------
int
main(int argc, char **argv)
{
    int     ret = 0;
    int     opt;
    int     timed = 0;
    char    cmd[10240];

    while (0 < (opt = getopt(argc, argv, "?c:dmp:s:tv-"))) {
        switch (opt) {

        case '?':
            help();
            break;
        case 'c':
            hxcrash = atoi(optarg);
            break;
        case 'd':
            ++hxdebug;
            break;
        case 'm':
            mmode |= HX_MMAP;
            break;
        case 's':
            mmode |= HX_FSYNC;
            break;
        case 't':
            timed++;
            break;
        case 'v':
            ++verbose;
            break;
        }
    }

    argc -= optind;
    argv += optind;

    setvbuf(stdout, NULL, _IOLBF, 0);
    setvbuf(stderr, NULL, _IOLBF, 0);
    errno = 0;                  //setvbuf sets errno !?

    int     size = 0;
    HXMODE  mode;
    HXFILE *hp = NULL;
    FILE   *fp = NULL;

    if (!*argv)
        die("See 'chx help' for usage");
    if (*argv[0] == '?' || !strcmp(argv[0], "help"))
        help();

    double  tstart = tick();

    if (hxdebug)
        hxtime = tstart;
    if (!strcmp(argv[0], "build")) {

        hp = do_hxopen("build", argv[1], HX_UPDATE);
        fp = do_fopen("build", argv[2], "r");
        int     memsize = argc > 3 ? atoi(argv[3]) : 1;
        int     inpsize = argc > 4 ? atoi(argv[4]) : 0;

        memsize <<= 20;
        is_hxret("build", hxbuild(hp, fp, memsize, inpsize));

    } else if (!strcmp(argv[0], "check")) {
        char   *udata = argc > 3 ? argv[3] : NULL;

        if (argc < 2)
            die("%s: requires filename [pgsize [udata]]", argv[0]);
        if (argc > 2 && !sscanf(argv[2], "%d", &size))
            die("%s: invalid pgsize", argv[2]);

        hp = do_hxopen("check", argv[1], HX_CHECK);
        mode = hxfix(hp, NULL, size, udata, udata ? strlen(udata) : 0);
        if (verbose || mode != HX_UPDATE)
            printf("%s %s\n", hxmode(mode), errno ? strerror(errno) : "");
        ret = mode != HX_UPDATE;

    } else if (!strcmp(argv[0], "create")) {

        if (argc < 3 || !sscanf(argv[2], "%d", &size))
            die("create: requires filename, pgsize, type");

        char const *type = argv[3] ? argv[3] : "";

        is_hxret("create", hxcreate(argv[1], 0644, size, type, strlen(type)));

        hp = do_hxopen("create", argv[1], HX_RECOVER);

    } else if (!strcmp(argv[0], "del")) {

        hp = do_hxopen("del", argv[1], HX_UPDATE);
        fp = do_fopen("del", argv[2], "r");
        del(hp, fp);

    } else if (!strcmp(argv[0], "dump")) {

        hp = do_hxopen("dump", argv[1], HX_READ);
        dump(hp, stdout);

    } else if (!strcmp(argv[0], "fix") || !strcmp(argv[0], "repair")) {
        char   *udata = argc > 3 ? argv[3] : NULL;

        if (argc < 2)
            die("%s: requires filename [pgsize [udata]]", argv[0]);

        if (argv[2] && !sscanf(argv[2], "%d", &size))
            die("%s: invalid pgsize", argv[2]);

        hp = do_hxopen("repair", argv[1], HX_UPDATE);
        fp = tmpfile();
        mode = hxfix(hp, fp, size, udata, udata ? strlen(udata) : 0);
        if (verbose || mode != HX_UPDATE)
            printf("%s %s\n", hxmode(mode), errno ? strerror(errno) : "");
        ret = mode != HX_UPDATE;

    } else if (!strcmp(argv[0], "hdrs")) {

        hp = do_hxopen("hdrs", argv[1], HX_READ);
        fp = do_fopen("hdrs", argv[2], "w");
        hdrs(hp);

    } else if (!strcmp(argv[0], "info")) {

        hp = do_hxopen("info", argv[1], HX_READ);
        info(hp);

    } else if (!strcmp(argv[0], "load")) {

        hp = do_hxopen("load", argv[1], HX_UPDATE);
        fp = do_fopen("hdrs", argv[2], "r");
        do_load(hp, fp);

    } else if (!strcmp(argv[0], "lock")) {

        hp = do_hxopen("lock", argv[1], HX_READ);
        do_lock(hp);

    } else if (!strcmp(argv[0], "maps")) {

        hp = do_hxopen("maps", argv[1], HX_READ);
        is_hxret("maps", maps(hp));

    } else if (!strcmp(argv[0], "pack")) {

        hp = do_hxopen("load", argv[1], HX_UPDATE);
        is_hxret("pack", hxpack(hp));

    } else if (!strcmp(argv[0], "save")) {

        hp = do_hxopen("save", argv[1], HX_READ);
        fp = do_fopen("save", argv[2], "w");
        do_save(hp, fp);

    } else if (!strcmp(argv[0], "shape")) {
        double  density;

        if (argc != 3 || !sscanf(argv[2], "%lf", &density))
            die("%s: requires density arg (0 to 1.0)", argv[2]);

        hp = do_hxopen("shape", argv[1], HX_UPDATE);
        is_hxret("shape", hxshape(hp, density));

    } else if (!strcmp(argv[0], "stat")) {

        hp = do_hxopen("stat", argv[1], HX_READ);
        stats(hp);

    } else if (!strcmp(argv[0], "types")) {
        // for each dir in LD_LIBRARY_PATH (and "" -> ".") then /lib then /usr/lib,
        //  find all files of the form "<dir>/hx_<rectype>.so"
        //      and build a file of unique rectypes.
        // Then call hxlib which returns an exact path and a bitmask of DIFF/LOAD/TEST
        //  "type diff-load-test path"
        // If the path matches, print the entry.

        types(getenv("LD_LIBRARY_PATH"));
        types("lib:/usr/lib");
    } else {

        die("%s: unknown command. See 'chx help'", cmd);
    }

    if (fp)
        fclose(fp);
    if (hp)
        hxclose(hp);
    if (timed)
        fprintf(stderr, "# chx %s: %.3f secs\n", *argv, tick() - tstart);

    return ret;
}
TEST(MapsTest, file_buffer_cross) {
  constexpr size_t kBufferSize = 2048;
  TemporaryFile tf;
  ASSERT_TRUE(tf.fd != -1);

  // Compute how many to add in the first buffer.
  size_t entry_len = CreateEntry(0).size();
  size_t index;
  std::string file_data;
  for (index = 0; index < kBufferSize / entry_len; index++) {
    file_data += CreateEntry(index);
  }
  // Add a long name to make sure that the first buffer does not contain a
  // complete line.
  // Remove the last newline.
  size_t extra = 0;
  size_t leftover = kBufferSize % entry_len;
  size_t overlap1_index = 0;
  std::string overlap1_name;
  if (leftover == 0) {
    // Exact match, add a long name to cross over the value.
    overlap1_name = "/fake/name/is/long/on/purpose";
    file_data.erase(file_data.size() - 1);
    file_data += ' ' + overlap1_name + '\n';
    extra = entry_len + overlap1_name.size() + 1;
    overlap1_index = index;
  }

  // Compute how many need to go in to hit the buffer boundary exactly.
  size_t bytes_left_in_buffer = kBufferSize - extra;
  size_t entries_to_add = bytes_left_in_buffer / entry_len + index;
  for (; index < entries_to_add; index++) {
    file_data += CreateEntry(index);
  }

  // Now figure out how many bytes to add to get exactly to the buffer boundary.
  leftover = bytes_left_in_buffer % entry_len;
  std::string overlap2_name;
  size_t overlap2_index = 0;
  if (leftover != 0) {
    file_data.erase(file_data.size() - 1);
    file_data += ' ';
    overlap2_name = std::string(leftover - 1, 'x');
    file_data += overlap2_name + '\n';
    overlap2_index = index - 1;
  }

  // Now add a few entries on the next page.
  for (size_t start = index; index < start + 10; index++) {
    file_data += CreateEntry(index);
  }

  ASSERT_TRUE(android::base::WriteStringToFile(file_data, tf.path, 0660, getuid(), getgid()));

  FileMaps maps(tf.path);
  ASSERT_TRUE(maps.Parse());
  EXPECT_EQ(index, maps.Total());
  // Verify all of the maps.
  for (size_t i = 0; i < index; i++) {
    MapInfo* info = maps.Get(i);
    ASSERT_TRUE(info != nullptr) << "Failed verifying index " + std::to_string(i);
    EXPECT_EQ(i * 4096, info->start) << "Failed verifying index " + std::to_string(i);
    EXPECT_EQ((i + 1) * 4096, info->end) << "Failed verifying index " + std::to_string(i);
    EXPECT_EQ(0U, info->offset) << "Failed verifying index " + std::to_string(i);
    if (overlap1_index != 0 && i == overlap1_index) {
      EXPECT_EQ(overlap1_name, info->name) << "Failed verifying overlap1 name " + std::to_string(i);
    } else if (overlap2_index != 0 && i == overlap2_index) {
      EXPECT_EQ(overlap2_name, info->name) << "Failed verifying overlap2 name " + std::to_string(i);
    } else {
      EXPECT_EQ("", info->name) << "Failed verifying index " + std::to_string(i);
    }
  }
}
Beispiel #27
0
void windy::app::on_assets_delete_pressed(nana::menu::item_proxy& ip) {
			
	if (this->_instance_creator->items().size() > 0) {

		switch (this->_instance_creator->category()) {
			case layer::kind::graphicable: {
				// references from graphicables and nuke 
				{
					for (auto item : this->_instance_creator->items()) {

						for (auto instance : item->instances()) {
							this->_environment->project()->remove(instance);
						}

						auto sprite =
							std::dynamic_pointer_cast<content::sprite>(item);

						this->_environment->project()->remove_sprite(sprite);
					}
				}

			}
			break;

			case layer::kind::groupable: {
				for (auto item : this->_instance_creator->items()) {

					// references from compositions and nuke if single-animation remains
					{
						auto compositions = 
						this->_environment->project()->assets()->collection()->
							get(layer::kind::compositable);

						std::vector <std::shared_ptr<content::composition> >
							compositions_nuked;

						for (auto composition_item : compositions) {
							auto composition = 
								std::dynamic_pointer_cast<content::composition>
								(composition_item);

							auto& instances = composition->instances();

							for (auto instance : instances) {
								auto compositable = 
									std::dynamic_pointer_cast
									<content::compositable>(instance);

								std::vector<std::shared_ptr<content::groupable> > 
									groupables_nuked;

								for (auto child : compositable->children()) {
									auto groupable = 
										std::dynamic_pointer_cast
										<content::groupable>(child);

									if (groupable->asset_uuid() == item->uuid()) {
										groupables_nuked.push_back(groupable);
										this->_environment->project()->assets()->
											collection()->remove(groupable);
									}

								}

								for (auto nuked : groupables_nuked) {
									auto& children = compositable->children();
									auto it = std::find(children.begin(), 
														children.end(),
														nuked);

									children.erase(it);
								}

							}

							composition->unmap(item);

							if (composition->maps().empty()) {
								compositions_nuked.push_back(composition);
							}
							
						}

						for (auto composition : compositions_nuked) {
							for (auto instance : composition->instances()) {
								this->_environment->project()->remove(instance);
							}

							this->_environment->project()->remove_composition(composition);
						}
					}
						
					// nuke timeline triggers 
					{

						for (auto instance : item->instances()) {
							auto groupable =
								std::dynamic_pointer_cast<content::groupable> (instance);

							for (auto trigger : groupable->triggers()) {
								this->_environment->timeline()->remove_trigger(trigger);
							}

						}

					}

					// references from groupables and nuke 

					{
						auto instances = item->instances(); // copy by reference to store the instances

						for (auto instance : instances) {
							this->_environment->project()->remove(instance);
						}

						auto group = std::dynamic_pointer_cast<content::group>(item);

						this->_environment->project()->remove_group(group);

					}
				}
			}
			break;

			case layer::kind::compositable: {
				// references from compositables and nuke 
				{
					for (auto item : this->_instance_creator->items()) {

						for (auto instance : item->instances()) {
							this->_environment->project()->remove(instance);
						}

						auto composition = 
							std::dynamic_pointer_cast<content::composition>(item);

						this->_environment->project()->remove_composition(composition);
					}
				}

			}
			break;

		}

		// refresh
		{
			this->_environment->project()->assets()->refresh();

//			this->_selection_targets.clear();

			this->_environment->edition()->refresh(this->_environment->project()->game()->container());

			this->_environment->properties()->clear();

			this->_environment->trigger_recalculation();
		}

	} else  {
		nana::msgbox error(this->handle(),
							L"Error");

		error << L"Please select one or more assets first.";

		error.show();
	}

}
int main (int argc, char *argv[])
{
  if ((argc < 5) || (argc > 6)) usage (argv[0]);
  std::string quad_list_prefix = argv[1];
  std::string alm_dir = argv[2];
  size_t Nstart, Nend;
  if (! Npoint_Functions::from_string (argv[3], Nstart)) {
    std::cerr << "Could not parse Nstart\n";
    usage (argv[0]);
  }
  if (! Npoint_Functions::from_string (argv[4], Nend)) {
    std::cerr << "Could not parse Nend\n";
    usage (argv[0]);
  }
  bool have_mask = false;
  Healpix_Map<double> mask;
  if (argc == 6) {
    read_Healpix_map_from_fits (argv[5], mask);
    have_mask = true;
  }

  // Figure out how many bins there are by trying to open files.
  std::vector<std::string> quad_list_files
    = Npoint_Functions::get_range_file_list(quad_list_prefix, 0, 400);
  if (quad_list_files.size() == 0) {
    std::cerr << "No quad list files found!\n";
    usage (argv[0]);
  }

  int Lmax;
  std::vector<Healpix_Map<double> > maps (Nend-Nstart);
  // Make maps
  {
    Npoint_Functions::Quadrilateral_List_File<int> qlf;
    qlf.initialize (quad_list_files[0]);
    if (have_mask) {
      if (static_cast<size_t>(mask.Nside()) != qlf.Nside()) {
        std::cerr << "Mask and quadrilateral lists do not have"
                  << " the same Nside: " << mask.Nside() 
                  << " != " << qlf.Nside() << std::endl;
        std::exit(1);
      }
      if (mask.Scheme() != qlf.Scheme()) mask.swap_scheme();
    }
    Lmax = std::min(200UL, 4*qlf.Nside()+1);
    //#pragma omp parallel shared(qlf, maps)
    {
      Alm<xcomplex<double> > alm (Lmax, Lmax);
      //#pragma omp for schedule(static)
      for (size_t k=0; k < maps.size(); ++k) {
        read_Alm_from_fits (dirtree::filename(alm_dir, "alm_T_", ".fits",
                                              k+Nstart),
                            alm, Lmax, Lmax);
        maps[k].SetNside (qlf.Nside(), RING);
        alm2map (alm, maps[k]);
        if (maps[k].Scheme() != qlf.Scheme()) maps[k].swap_scheme();
      }
    }
  }

  std::vector<double> bin_list(quad_list_files.size());
  /* We will generate this by bin for each map so make the bin number the
   * first index. */
  std::vector<std::vector<double> > Corr(quad_list_files.size());

#pragma omp parallel shared(Corr, bin_list, quad_list_files, maps, mask)
  {
    Npoint_Functions::Quadrilateral_List_File<int> qlf;
    
#pragma omp for schedule(dynamic,2)
    for (size_t k=0; k < quad_list_files.size(); ++k) {
      if (! qlf.initialize (quad_list_files[k])) {
        std::cerr << "Error initializing quadrilateral list from "
                  << quad_list_files[k] << std::endl;
        std::exit(1);
      }

      bin_list[k] = qlf.bin_value();
      if (have_mask) {
        Npoint_Functions::calculate_masked_fourpoint_function_list
          (maps, mask, qlf, Corr[k]);
      } else {
        Npoint_Functions::calculate_fourpoint_function_list
          (maps, qlf, Corr[k]);
      }
    }
  }
  
  std::cout << "# LCDM four point function from " << quad_list_prefix
            << std::endl;
  std::cout << "# First line is bin values, rest are the four point function.\n";
  for (size_t k=0; k < bin_list.size(); ++k) {
    std::cout << bin_list[k] << " ";
  }
  std::cout << std::endl;

  for (size_t j=0; j < maps.size(); ++j) {
    for (size_t k=0; k < bin_list.size(); ++k) {
      std::cout << Corr[k][j] << " ";
    }
    std::cout << std::endl;
  }

  return 0;
}
Beispiel #29
0
// Determine UNIX processes by reading "/proc". Default to ps if
// it does not exist
ProcDataList processList(const ProcDataList& previous)
{
    const QDir procDir(QLatin1String("/proc/"));
    if (!procDir.exists())
        return unixProcessListPS(previous);
    ProcDataList rc;
    const QStringList procIds = procDir.entryList();
    if (procIds.isEmpty())
        return rc;
    foreach (const QString &procId, procIds) {
        if (!isUnixProcessId(procId))
            continue;
        QString filename = QLatin1String("/proc/");
        filename += procId;
        filename += QLatin1String("/stat");
        QFile file(filename);
        if (!file.open(QIODevice::ReadOnly))
            continue;           // process may have exited

        const QStringList data = QString::fromLocal8Bit(file.readAll()).split(' ');
        ProcData proc;
        proc.ppid = procId;
        proc.name = data.at(1);
        if (proc.name.startsWith(QLatin1Char('(')) && proc.name.endsWith(QLatin1Char(')'))) {
            proc.name.truncate(proc.name.size() - 1);
            proc.name.remove(0, 1);
        }
        proc.state = data.at(2);
        // PPID is element 3

        proc.user = QFileInfo(file).owner();
        file.close();

        QFile cmdFile(QLatin1String("/proc/") + procId + QLatin1String("/cmdline"));
        if(cmdFile.open(QFile::ReadOnly)) {
          QByteArray cmd = cmdFile.readAll();
          cmd.replace('\0', ' ');
          if ( !cmd.isEmpty() )
            proc.name = QString::fromLocal8Bit(cmd);
        }
        cmdFile.close();

        QFile maps(QLatin1String("/proc/") + procId + QLatin1String("/maps"));
        if (!maps.open(QIODevice::ReadOnly))
          continue; // process may have exited

        proc.type = ProcData::NoQtApp;
        forever {
          const QByteArray line = maps.readLine();
          if (line.isEmpty()) {
            break;
          }
          if (line.contains(QByteArray("/libQtCore.so"))) {
            proc.type = ProcData::QtApp;
            break;
          }
        }

        rc.push_back(proc);
    }
    return rc;
}
Beispiel #30
0
int	main()
{
  pixel();
  maps();
}