solver.c 15.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/* solver.c - Alpine Package Keeper (APK)
 * A backtracking, forward checking dependency graph solver.
 *
 * Copyright (C) 2011 Timo Teräs <timo.teras@iki.fi>
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation. See http://www.gnu.org/ for details.
 */

/* FIXME: install-if not supported yet */

#include <stdlib.h>
#include "apk_defines.h"
#include "apk_database.h"
#include "apk_package.h"
#include "apk_solver.h"

#if 0
#include <stdio.h>
#define dbg_printf(args...) fprintf(stderr, args)
#else
#define dbg_printf(args...)
#endif

#define APK_PKGSTF_NOINSTALL		0
#define APK_PKGSTF_INSTALL		1
#define APK_PKGSTF_BRANCH		2
#define APK_PKGSTF_ALT_BRANCH		4

struct apk_package_state {
	struct apk_package *backtrack;
	unsigned short flags;
	unsigned short conflicts;
36
	unsigned short cur_unsatisfiable;
37 38
};

39
#define APK_NAMESTF_AVAILABILITY_CHECKED	1
40 41
#define APK_NAMESTF_LOCKED			2
#define APK_NAMESTF_NO_OPTIONS			4
42 43 44
struct apk_name_state {
	struct list_head unsolved_list;
	struct apk_package *chosen;
45
	unsigned short flags;
46 47 48 49 50 51 52 53 54 55 56
	unsigned short requirers;
};

struct apk_solver_state {
	struct apk_database *db;
	struct apk_package_state *pkg_state;
	struct apk_name_state *name_state;
	struct list_head unsolved_list_head;
	struct apk_package *latest_decision;
	unsigned int topology_position;
	unsigned int assigned_names;
57 58
	unsigned short cur_unsatisfiable;
	unsigned short allow_errors;
59 60

	struct apk_package_array *best_solution;
61
	unsigned short best_unsatisfiable;
62 63
};

64 65 66 67
static void apply_constraint(struct apk_solver_state *ss, struct apk_dependency *dep);
static void undo_constraint(struct apk_solver_state *ss, struct apk_dependency *dep);
static void push_decision(struct apk_solver_state *ss, struct apk_package *pkg,
			  int flags);
68 69 70 71 72 73 74 75 76 77 78 79

static inline int pkg_available(struct apk_database *db, struct apk_package *pkg)
{
	if (pkg->installed_size == 0)
		return TRUE;
	if (pkg->filename != NULL)
		return TRUE;
	if (apk_db_select_repo(db, pkg) != NULL)
		return TRUE;
	return FALSE;
}

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
static void prepare_name(struct apk_solver_state *ss, struct apk_name *name,
			 struct apk_name_state *ns)
{
	int i;

	if (ns->flags & APK_NAMESTF_AVAILABILITY_CHECKED)
		return;

	for (i = 0; i < name->pkgs->num; i++) {
		struct apk_package *pkg = name->pkgs->item[i];
		struct apk_package_state *ps = &ss->pkg_state[pkg->topology_sort];

		/* if package is needed for (re-)install */
		if ((name->flags & APK_NAME_REINSTALL) || (pkg->ipkg == NULL)) {
			/* and it's not available, we can't use it */
			if (!pkg_available(ss->db, pkg))
				ps->conflicts++;
		}
	}

	ns->flags |= APK_NAMESTF_AVAILABILITY_CHECKED;
}

103 104
static void foreach_dependency(struct apk_solver_state *ss, struct apk_dependency_array *deps,
			       void (*func)(struct apk_solver_state *ss, struct apk_dependency *dep))
105
{
106
	int i;
107
	for (i = 0; i < deps->num; i++)
108
		func(ss, &deps->item[i]);
109 110
}

111
static int inline can_consider_package(struct apk_solver_state *ss, struct apk_package *pkg)
112
{
113
	struct apk_package_state *ps = &ss->pkg_state[pkg->topology_sort];
114
	if (pkg->topology_sort > ss->topology_position)
115 116 117 118 119 120
		return FALSE;
	if (ps->conflicts)
		return FALSE;
	return TRUE;
}

121
static int get_pkg_expansion_flags(struct apk_solver_state *ss, struct apk_package *pkg)
122 123
{
	struct apk_name *name = pkg->name;
124
	int i, options = 0;
125 126 127

	/* check if the suggested package is the most preferred one of
	 * available packages for the name */
128
	for (i = 0; i < name->pkgs->num; i++) {
129
		struct apk_package *pkg0 = name->pkgs->item[i];
130

131
		if (pkg0 == pkg || !can_consider_package(ss, pkg0))
132 133
			continue;

134 135 136
		if (apk_flags & APK_PREFER_AVAILABLE) {
			/* pkg available, pkg0 not */
			if (pkg->repos != 0 && pkg0->repos == 0)
137
				continue;
138 139
			/* pkg0 available, pkg not */
			if (pkg0->repos != 0 && pkg->repos == 0)
140
				return APK_PKGSTF_NOINSTALL | APK_PKGSTF_BRANCH;
141 142
		}

143 144
		if (!(apk_flags & APK_UPGRADE)) {
			/* not upgrading, prefer the installed package */
145 146
			if (pkg->ipkg == NULL && pkg0->ipkg != NULL)
				return APK_PKGSTF_NOINSTALL | APK_PKGSTF_BRANCH;
147 148 149 150
		}

		/* upgrading, or neither of the package is installed, so
		 * we just fall back comparing to versions */
151
		options++;
152
		if (apk_pkg_version_compare(pkg0, pkg) == APK_VERSION_GREATER)
153
			return APK_PKGSTF_NOINSTALL | APK_PKGSTF_BRANCH;
154 155
	}

156
	/* no package greater than the selected */
157 158 159 160 161
	if (options)
		return APK_PKGSTF_INSTALL | APK_PKGSTF_BRANCH;

	/* no other choice */
	return APK_PKGSTF_INSTALL;
162 163 164
}

static int update_name_state(struct apk_solver_state *ss,
165 166
			     struct apk_name *name, struct apk_name_state *ns,
			     int requirers_adjustment)
167 168 169 170
{
	struct apk_package *pkg_best = NULL;
	int i, options = 0;

171 172
	ns->requirers += requirers_adjustment;

173 174 175
	for (i = 0; i < name->pkgs->num; i++) {
		struct apk_package *pkg0 = name->pkgs->item[i];

176
		if (!can_consider_package(ss, pkg0))
177 178 179 180 181 182 183
			continue;

		options++;
		if (pkg_best == NULL ||
		    pkg0->topology_sort > pkg_best->topology_sort)
			pkg_best = pkg0;
	}
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

	if (options == 0) {
		if (!(ns->flags & APK_NAMESTF_NO_OPTIONS)) {
			ss->cur_unsatisfiable += ns->requirers;
			ns->flags |= APK_NAMESTF_NO_OPTIONS;
		} else if (requirers_adjustment > 0) {
			ss->cur_unsatisfiable += requirers_adjustment;
		}
	} else
		ns->flags &= ~APK_NAMESTF_NO_OPTIONS;

	if (options == 0 || ns->requirers == 0) {
		if (list_hashed(&ns->unsolved_list)) {
			list_del(&ns->unsolved_list);
			list_init(&ns->unsolved_list);
			ns->chosen = NULL;
		}
		dbg_printf("%s: deleted from unsolved: %d requirers, %d options\n",
			   name->name, ns->requirers, options);
	} else {
		dbg_printf("%s: added to unsolved: %d requirers, %d options (next topology %d)\n",
			   name->name, ns->requirers, options, pkg_best->topology_sort);
		if (!list_hashed(&ns->unsolved_list))
			list_add(&ns->unsolved_list, &ss->unsolved_list_head);
		ns->chosen = pkg_best;
	}

211 212 213
	return options;
}

214 215 216
static void apply_decision(struct apk_solver_state *ss,
			   struct apk_package *pkg,
			   struct apk_package_state *ps)
217 218 219 220 221 222 223 224 225
{
	struct apk_name_state *ns = &ss->name_state[pkg->name->id];

	dbg_printf("apply_decision: " PKG_VER_FMT " %s\n", PKG_VER_PRINTF(pkg),
		   (ps->flags & APK_PKGSTF_INSTALL) ? "INSTALL" : "NO_INSTALL");

	if (ps->flags & APK_PKGSTF_INSTALL) {
		ss->assigned_names++;
		ns->chosen = pkg;
226 227 228 229 230 231 232 233
		ns->flags |= APK_NAMESTF_LOCKED;

		list_del(&ns->unsolved_list);
		list_init(&ns->unsolved_list);
		dbg_printf("%s: deleting from unsolved list\n",
			   pkg->name->name);

		foreach_dependency(ss, pkg->depends, apply_constraint);
234
	} else {
235 236
		ps->conflicts++;
		update_name_state(ss, pkg->name, ns, 0);
237 238 239 240 241 242 243 244 245 246 247 248
	}
}

static void undo_decision(struct apk_solver_state *ss,
			  struct apk_package *pkg,
			  struct apk_package_state *ps)
{
	struct apk_name_state *ns = &ss->name_state[pkg->name->id];

	dbg_printf("undo_decision: " PKG_VER_FMT " %s\n", PKG_VER_PRINTF(pkg),
		   (ps->flags & APK_PKGSTF_INSTALL) ? "INSTALL" : "NO_INSTALL");

249 250 251 252
	ss->cur_unsatisfiable = ps->cur_unsatisfiable;
	if (ps->flags & APK_PKGSTF_BRANCH)
		ss->topology_position = pkg->topology_sort;

253 254 255 256
	if (ps->flags & APK_PKGSTF_INSTALL) {
		ss->assigned_names--;
		foreach_dependency(ss, pkg->depends, undo_constraint);

257 258 259 260
		ns->flags &= ~APK_NAMESTF_LOCKED;
		ns->chosen = NULL;
	} else {
		ps->conflicts--;
261
	}
262 263

	update_name_state(ss, pkg->name, ns, 0);
264 265
}

266 267
static void push_decision(struct apk_solver_state *ss, struct apk_package *pkg,
			  int flags)
268 269 270 271 272
{
	struct apk_package_state *ps = &ss->pkg_state[pkg->topology_sort];

	ps->backtrack = ss->latest_decision;
	ps->flags = flags;
273
	ps->cur_unsatisfiable = ss->cur_unsatisfiable;
274
	ss->latest_decision = pkg;
275

276 277 278 279 280 281 282
	if (flags & APK_PKGSTF_BRANCH) {
		ss->topology_position = pkg->topology_sort;
		dbg_printf("push_decision: adding new BRANCH at topology_position %d\n",
			   ss->topology_position);
	} else
		ps->flags |= APK_PKGSTF_ALT_BRANCH;

283
	apply_decision(ss, pkg, ps);
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
}

static int next_branch(struct apk_solver_state *ss)
{
	struct apk_package *pkg;
	struct apk_package_state *ps;

	while (1) {
		pkg = ss->latest_decision;
		ps = &ss->pkg_state[pkg->topology_sort];
		undo_decision(ss, pkg, ps);

		if (ps->flags & APK_PKGSTF_ALT_BRANCH) {
			pkg = ps->backtrack;
			ss->latest_decision = pkg;
299 300
			if (pkg == NULL) {
				dbg_printf("next_branch: no more branches\n");
301
				return 1;
302
			}
303 304 305 306 307 308 309 310 311
			dbg_printf("next_branch: undo decision at topology_position %d\n",
				   ss->topology_position);
		} else {
			dbg_printf("next_branch: swapping BRANCH at topology_position %d\n",
				   ss->topology_position);

			ps->flags |= APK_PKGSTF_ALT_BRANCH;
			ps->flags ^= APK_PKGSTF_INSTALL;

312 313
			apply_decision(ss, pkg, ps);
			return 0;
314 315 316 317
		}
	}
}

318
static void apply_constraint(struct apk_solver_state *ss, struct apk_dependency *dep)
319 320 321
{
	struct apk_name *name = dep->name;
	struct apk_name_state *ns = &ss->name_state[name->id];
322
	int i;
323

324
	prepare_name(ss, name, ns);
325 326 327 328 329 330 331 332 333

	if (ns->flags & APK_NAMESTF_LOCKED) {
		dbg_printf(PKG_VER_FMT " selected already for %s\n",
			   PKG_VER_PRINTF(ns->chosen), dep->name->name);
		if (!apk_dep_is_satisfied(dep, ns->chosen))
			ss->cur_unsatisfiable += 200;
		return;
	}

334 335 336 337
	for (i = 0; i < name->pkgs->num; i++) {
		struct apk_package *pkg0 = name->pkgs->item[i];
		struct apk_package_state *ps0 = &ss->pkg_state[pkg0->topology_sort];

338
		if (pkg0->topology_sort >= ss->topology_position)
339 340 341 342 343 344 345 346 347 348
			continue;

		if (!apk_dep_is_satisfied(dep, pkg0)) {
			ps0->conflicts++;
			dbg_printf(PKG_VER_FMT ": conflicts++ -> %d\n",
				   PKG_VER_PRINTF(pkg0),
				   ps0->conflicts);
		}
	}

349 350
	update_name_state(ss, name, ns,
			  (dep->result_mask != APK_DEPMASK_CONFLICT) ? 1 : 0);
351 352
}

353
static void undo_constraint(struct apk_solver_state *ss, struct apk_dependency *dep)
354 355 356
{
	struct apk_name *name = dep->name;
	struct apk_name_state *ns = &ss->name_state[name->id];
357 358 359 360 361 362 363
	int i;

	if (ns->flags & APK_NAMESTF_LOCKED) {
		dbg_printf(PKG_VER_FMT " selected already for %s\n",
			   PKG_VER_PRINTF(ns->chosen), dep->name->name);
		return;
	}
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379

	for (i = 0; i < name->pkgs->num; i++) {
		struct apk_package *pkg0 = name->pkgs->item[i];
		struct apk_package_state *ps0 = &ss->pkg_state[pkg0->topology_sort];

		if (pkg0->topology_sort >= ss->topology_position)
			continue;

		if (!apk_dep_is_satisfied(dep, pkg0)) {
			ps0->conflicts--;
			dbg_printf(PKG_VER_FMT ": conflicts-- -> %d\n",
				   PKG_VER_PRINTF(pkg0),
				   ps0->conflicts);
		}
	}

380 381
	update_name_state(ss, name, ns,
		(dep->result_mask != APK_DEPMASK_CONFLICT) ? -1 : 0);
382 383 384 385
}

static int expand_branch(struct apk_solver_state *ss)
{
386 387 388 389 390 391 392 393 394 395 396 397 398 399
	struct apk_name_state *ns;
	struct apk_package *pkg0 = NULL;

	/* FIXME: change unsolved_list to a priority queue */
	list_for_each_entry(ns, &ss->unsolved_list_head, unsolved_list) {
		if (pkg0 == NULL ||
		    ns->chosen->topology_sort > pkg0->topology_sort)
			pkg0 = ns->chosen;
	}
	if (pkg0 == NULL) {
		dbg_printf("expand_branch: list is empty (%d unsatisfied)\n",
			   ss->cur_unsatisfiable);
		return 1;
	}
400

401 402 403 404
	/* someone needs to provide this name -- find next eligible
	 * provider candidate */
	ns = &ss->name_state[pkg0->name->id];
	dbg_printf("expand_branch: %s %d\n", pkg0->name->name, pkg0->topology_sort);
405

406 407 408 409 410 411
	push_decision(ss, pkg0, get_pkg_expansion_flags(ss, pkg0));
	#if 0
		      is_pkg_preferred(ss, pkg0) ?
			(APK_PKGSTF_INSTALL | APK_PKGSTF_BRANCH) :
			(APK_PKGSTF_NOINSTALL | APK_PKGSTF_BRANCH));
			#endif
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427

	return 0;
}

static void record_solution(struct apk_solver_state *ss)
{
	struct apk_package *pkg;
	struct apk_package_state *ps;
	int i;

	apk_package_array_resize(&ss->best_solution, ss->assigned_names);

	i = 0;
	pkg = ss->latest_decision;
	while (pkg != NULL) {
		ps = &ss->pkg_state[pkg->topology_sort];
428 429
		if ((ps->flags & APK_PKGSTF_INSTALL) &&
		    (ps->conflicts == 0))
430 431 432 433 434 435 436 437
			ss->best_solution->item[i++] = pkg;

		dbg_printf("record_solution: " PKG_VER_FMT ": %sINSTALL\n",
			   PKG_VER_PRINTF(pkg),
			   (ps->flags & APK_PKGSTF_INSTALL) ? "" : "NO_");

		pkg = ps->backtrack;
	}
438 439 440 441 442 443 444 445 446 447
	apk_package_array_resize(&ss->best_solution, i);
	ss->best_unsatisfiable = ss->cur_unsatisfiable;
}

static int compare_package_name(const void *p1, const void *p2)
{
	const struct apk_package **c1 = (const struct apk_package **) p1;
	const struct apk_package **c2 = (const struct apk_package **) p2;

	return strcmp((*c1)->name->name, (*c2)->name->name);
448 449 450
}

int apk_solver_solve(struct apk_database *db, struct apk_dependency_array *world,
451
		     struct apk_package_array **solution, int allow_errors)
452 453 454 455 456 457 458
{
	struct apk_solver_state *ss;
	int r;

	ss = calloc(1, sizeof(struct apk_solver_state));
	ss->db = db;
	ss->topology_position = -1;
459 460
	ss->best_unsatisfiable = -1;
	ss->allow_errors = allow_errors;
461 462 463 464
	list_init(&ss->unsolved_list_head);
	ss->pkg_state = calloc(db->available.packages.num_items+1, sizeof(struct apk_package_state));
	ss->name_state = calloc(db->available.names.num_items+1, sizeof(struct apk_name_state));

465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	foreach_dependency(ss, world, apply_constraint);
	do {
		if (ss->allow_errors || ss->cur_unsatisfiable < ss->best_unsatisfiable) {
			r = expand_branch(ss);
			if (r) {
				if (ss->cur_unsatisfiable == 0) {
					/* found solution - it is optimal because we permutate
					 * each preferred local option first, and permutations
					 * happen in topologally sorted order. */
					r = 0;
					break;
				}
				if (ss->cur_unsatisfiable < ss->best_unsatisfiable)
					record_solution(ss);
				r = next_branch(ss);
			}
		} else {
			r = next_branch(ss);
483
		}
484
	} while (r == 0);
485 486

	/* collect packages */
487
	if (r == 0 && ss->cur_unsatisfiable == 0) {
488 489
		record_solution(ss);
		*solution = ss->best_solution;
490 491 492 493 494 495 496 497
		r = 0;
	} else if (ss->allow_errors) {
		*solution = ss->best_solution;
		qsort(ss->best_solution->item, ss->best_solution->num,
		      sizeof(struct apk_package *), compare_package_name);
		r = ss->best_unsatisfiable;
	} else
		r = -1;
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581

	free(ss->name_state);
	free(ss->pkg_state);
	free(ss);

	return r;
}

static int compare_change(const void *p1, const void *p2)
{
	const struct apk_change *c1 = (const struct apk_change *) p1;
	const struct apk_change *c2 = (const struct apk_change *) p2;

	if (c1->newpkg == NULL) {
		if (c2->newpkg == NULL)
			/* both deleted - reverse topology order */
			return c1->oldpkg->topology_sort - c2->oldpkg->topology_sort;

		/* c1 deleted, c2 installed -> c2 first*/
		return -1;
	}
	if (c2->newpkg == NULL)
		/* c1 installed, c2 deleted -> c1 first*/
		return 1;

	return c2->newpkg->topology_sort - c1->newpkg->topology_sort;
}

int apk_solver_generate_changeset(struct apk_database *db,
				  struct apk_package_array *solution,
				  struct apk_changeset *changeset)
{
	struct apk_name *name;
	struct apk_package *pkg, *pkg0;
	struct apk_installed_package *ipkg;
	int num_installs = 0, num_removed = 0, ci = 0;
	int i, j;

	/* calculate change set size */
	for (i = 0; i < solution->num; i++) {
		pkg = solution->item[i];
		name = pkg->name;
		if (pkg->ipkg == NULL || (name->flags & APK_NAME_REINSTALL))
			num_installs++;
		name->flags |= APK_NAME_VISITED;
	}

	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		if (!(ipkg->pkg->name->flags & APK_NAME_VISITED))
			num_removed++;
	}

	/* construct changeset */
	apk_change_array_resize(&changeset->changes, num_installs + num_removed);
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		if (ipkg->pkg->name->flags & APK_NAME_VISITED)
			continue;
		changeset->changes->item[ci].oldpkg = ipkg->pkg;
		ci++;
	}
	for (i = 0; i < solution->num; i++) {
		pkg = solution->item[i];
		name = pkg->name;

		if (pkg->ipkg == NULL || (name->flags & APK_NAME_REINSTALL)) {
			for (j = 0; j < name->pkgs->num; j++) {
				pkg0 = name->pkgs->item[j];
				if (pkg0->ipkg == NULL)
					continue;
				changeset->changes->item[ci].oldpkg = pkg0;
				break;
			}
			changeset->changes->item[ci].newpkg = pkg;
			ci++;
		}
		name->flags &= ~APK_NAME_VISITED;
	}

	/* sort changeset to topology order */
	qsort(changeset->changes->item, changeset->changes->num,
	      sizeof(struct apk_change), compare_change);

	return 0;
}