Exemple #1
0
static int64_t path_parent_child(const char *path, const char **child, int flags)
{
	int64_t parent_inum; uint max_len, leaf_idx;
	mode_t leaf_type;

	max_len = PAGE_SIZE;
	leaf_idx = path_get_leaf(path, &leaf_type);
	if ((flags & NO_DIR) && S_ISDIR(leaf_type))
		return -EISDIR;
	if (path[0] == '/')
		assert(leaf_idx != 0);
	if (leaf_idx == 0)
		parent_inum = current->working_dir;
	else if (leaf_idx >= max_len)
		return -ENAMETOOLONG;
	else {
		char *parent = kmalloc(leaf_idx + 1);
		memcpy(parent, path, leaf_idx);
		parent[leaf_idx] = '\0';
		parent_inum = name_i(parent);
		kfree(parent);
		if (parent_inum < 0)
			return parent_inum;
	}
	*child = &path[leaf_idx];
	return parent_inum;
}
Exemple #2
0
/*
 * -ENOENT, -ENOTDIR, -ENAMETOOLONG
 */
int sys_stat(const char *path, struct stat *buf)
{
	uint64_t inum;

	inum = name_i(path);
	if (inum < 0)
		return inum;

	fill_statbuf(inum, buf);
	return 0;
}
Exemple #3
0
/*
 * -ENOENT, -ENOTDIR, -ENAMETOOLONG
 */
int sys_chdir(const char *path)
{
	int64_t inum;

	inum = name_i(path);
	if (inum < 0)
		return inum;
	if (!is_dir(inum))
		return -ENOTDIR;

	assert(inum != 0);
	current->working_dir = inum;
	return 0;
}
Exemple #4
0
int sys_link(const char *oldpath, const char *newpath)
{
	int64_t inum, parent_inum;
	const char *child;
	struct inode *inode;

	parent_inum = path_parent_child(newpath, &child, OK_DIR);
	if (parent_inum < 0)
		return parent_inum;
	inum = name_i(oldpath);
	if (inum < 0)
		return inum;
	inode = inode_get(inum);

	return ext2_new_dir_entry(parent_inum, inum, child,
				  inode_mode_to_dir_entry_type(inode->mode));
}
Exemple #5
0
/*
 * -EINVAL, -EEXIST, -ENOENT, -ENOTDIR, -ENAMETOOLONG, -EISDIR
 */
int sys_open(const char *path, int flags, __unused mode_t mode)
{
	int64_t parent_inum, inum, fd;
	struct file *file;
	const char *child;

	if ((flags & O_ACCMODE) == 0)
		return -EINVAL;
	if ((flags & O_TRUNC) &&
	    (flags & O_APPEND || (flags & O_WRONLY) == 0))
		return -EINVAL;

	inum = name_i(path);
	if (flags & O_CREAT) {
		if (inum > 0 && (flags & O_EXCL))
			return -EEXIST;
		if (inum == -ENOENT) {
			parent_inum = path_parent_child(path, &child, NO_DIR);
			inum = (parent_inum < 0) ? parent_inum :
				file_new(parent_inum, child, EXT2_FT_REG_FILE);
		}
	}
	if (inum < 0)
		return inum;
	if (is_dir(inum))
		return -EISDIR;

	file = kmalloc(sizeof(*file));
	file_init(file, inum, flags);
	fd = unrolled_insert(&current->fdtable, file);
	if (flags & O_TRUNC)
		file_truncate(inum);
	if (flags & O_APPEND)
		assert(sys_lseek(fd, 0, SEEK_END) > 0);
	return fd;
}
void BppSolver::generateBranches(real lp_value, CoupleItem couple, BranchNode& currentNode, TreeNodes& nodes)
{
	BranchNode separateBranch(lp_value, couple, SEPARATE, currentNode);
	BranchNode togetherBranch(lp_value, couple, TOGETHER, currentNode);

	std::vector<std::size_t> cols_i;
	std::vector<std::size_t> cols_j;
	std::vector<std::size_t> invalide_together(BPmodel.nbVars());
	std::vector<std::size_t> invalide_separate(BPmodel.nbVars());


	IloExpr::LinearIterator it_i = BPmodel.getLinearCoefIterator(couple.first);
	IloExpr::LinearIterator it_j = BPmodel.getLinearCoefIterator(couple.second);

	bool validColumn_it;
	while (it_i.ok())
	{
		std::string name_i(it_i.getVar().getName());
		int si = std::stoi(name_i.substr(1));
		validColumn_it = true;
		for (auto cols : currentNode.incumbentInvalidColumns) {
			if (!(validColumn_it = (cols->find(si) == cols->end())))
				break;
		}
		if (validColumn_it)
			cols_i.push_back(std::stoi(name_i.substr(1)));
		++it_i;
	}
	while (it_j.ok())
	{
		std::string name_j(it_j.getVar().getName());
		int sj = std::stoi(name_j.substr(1));
		validColumn_it = true;
		for (auto cols : currentNode.incumbentInvalidColumns) {
			if (!(validColumn_it = (cols->find(sj) == cols->end())))
				break;
		}
		if (validColumn_it)
			cols_j.push_back(std::stoi(name_j.substr(1)));
		++it_j;
	}

	std::vector<std::size_t>::iterator it;
	it = std::set_intersection(cols_i.begin(), cols_i.end(), cols_j.begin(), cols_j.end(), invalide_separate.begin());
	invalide_separate.resize(it - invalide_separate.begin());
	for (auto i : invalide_separate)
		separateBranch.invalidColumns->insert(i);

	it = std::set_symmetric_difference(cols_i.begin(), cols_i.end(), cols_j.begin(), cols_j.end(), invalide_together.begin());
	invalide_together.resize(it - invalide_together.begin());
	for (auto i : invalide_together)
		togetherBranch.invalidColumns->insert(i);

	srand(time(0));
	int randomval = rand() % 2;

	if (randomval == 1) {
		TogetherBranch(togetherBranch, separateBranch, nodes);
	}
	else {
		SeparateBranch(togetherBranch, separateBranch, nodes);
	}
}
CoupleItem BppSolver::ryanFosterCouple(BranchNode& node)
{
	// get var values
	auto& Xs = BPmodel.getPrimalValues();
	

#ifdef DBG_OUTPUT
	for (int i = 0; i < BPVars.getSize(); i++)
		std::cout << Xs[i] << " ";
	std::cout << std::endl;
#endif

	std::vector<std::size_t> vec_shuffled(Xs.getSize());
	std::iota(vec_shuffled.begin(), vec_shuffled.end(), 0);
	// shuffle

	auto engine = std::default_random_engine(std::random_device{}());
	std::shuffle(vec_shuffled.begin(), vec_shuffled.end(), engine);

	std::list<std::size_t> vi(vec_shuffled.begin(), vec_shuffled.end());
	std::shuffle(vec_shuffled.begin(), vec_shuffled.end(), engine);
	std::list<std::size_t> vj(vec_shuffled.begin(), vec_shuffled.end());

	for (auto it = vi.begin(); it != vi.end(); it++)
	{
		int i = *it;
		auto jt = vj.begin();
		while (jt != vj.end())
		{
			int j = *jt;
			if (i == j)
				jt = vj.erase(jt);
			else
			{
				IloExpr::LinearIterator it_i = BPmodel.getLinearCoefIterator(i);
				IloExpr::LinearIterator it_j = BPmodel.getLinearCoefIterator(j);

				real sumVars = 0.0;
				for (; ; )
				{
					// get index of the variables via thier names
					std::string name_i(it_i.getVar().getName());
					std::string name_j(it_j.getVar().getName());
					// si and sj are the column index of the iterators
					int si = std::stoi(name_i.substr(1));
					int sj = std::stoi(name_j.substr(1));
					// booleans for validity of the columns
					bool validColumn_it = true;

					// i and j are in the same bin
					if (si == sj)
					{
						for (auto cols : node.incumbentInvalidColumns) {
							if (!(validColumn_it = (cols->find(sj) == cols->end())))
								break;
						}

						if (validColumn_it)
							validColumn_it = (node.invalidColumns->find(si) == node.invalidColumns->end());

						if (validColumn_it && (Xs[si] > 0.0))
							sumVars += Xs[si];
					}
					// some requirement to increment the iterator 
					// since they itarate only over non zero coefs
					if (si <= sj)
						++it_i;
					++it_j;
					// stop condition
					if (!it_i.ok() || !it_j.ok())
						break;
				}
				real _dumy;
				real frac = modf(sumVars, &_dumy);
				if (frac >= 0.0001) {
					return std::make_pair(i, j);
				}
				++jt;
			}
		}
	}
}