#
# cgc_forward -- counts forward references (update and reads)
# cgc_deref -- counts scans of the newspace area
# cgc_updates -- counts updates for forwarding pointer
#
# _cwrd counts words copied (transports and promotes)
# _pwrd counts promotes

function abs(x) {
	if (x < 0) return -x;
	else return x;
}

function update (idx) {
	unknown = $2
	fix = $3
	char = $4
	big = $5
	float = $6 + $7
	string = $8
	ivec = $9 + $10
	special = $11
	conscount = $12
	ratcomp = $13 + $14
	symbol = $15
	nil = $16
	gvec = $17 + $18 + $19
	totalcount = $20
	cons[idx] = conscount
	fixed[idx] = float + ratcomp + symbol + nil + unknown + fix + char
	variable[idx] = big + string + ivec + special + gvec
	total[idx] = totalcount;
}

function update_totals() {

	total_length += pause_length;

	for (idx in indices) {
		totalcons[idx] += cons[idx];
		totalfixed[idx] += fixed[idx];
		totalvariable[idx] += variable[idx];
		totaltotal[idx] += total[idx];
	}
	
	total_updates += updates;
	total_forwards += forwards;
	total_derefs += derefs;
}

function check_values () {

	for (idx in indices) {
		if (cons[idx] + fixed[idx] + variable[idx] != total[idx]) {
			printf "ERROR -- bad sum: %s, cons %d, fixed %d, variable %d, total %d\n", \
				idx, cons[idx], fixed[idx], variable[idx], total[idx]
			exit;
		}
		if (totalcons[idx] + totalfixed[idx] + totalvariable[idx] != totaltotal[idx]) {
			printf "ERROR -- bad total sum: %s, cons %d, fixed %d, variable %d, total %d\n", \
				idx, totalcons[idx], totalfixed[idx], totalvariable[idx], totaltotal[idx]
			exit;
		}
	}
}

function print_values () {

	for (idx in indices) {
		printf "CHECK: %s, cons %d, fixed %d, variable %d, total %d\n", \
			idx, cons[idx], fixed[idx], variable[idx], total[idx]
	}
	for (idx in indices) {
		printf "CHECK: totals: %s, cons %d, fixed %d, variable %d, total %d\n", \
			idx, totalcons[idx], totalfixed[idx], totalvariable[idx], totaltotal[idx]
	}
}

function initialize() {

	indices["cw"] = "cw"
	indices["co"] = "co"
	indices["aw"] = "aw"
	indices["ao"] = "ao"
	indices["pw"] = "pw"
	indices["po"] = "po"

	for (idx in indices) {
		totalfixed[idx] = 0;
		totalcons[idx] = 0;
		totalvariable[idx] = 0;
		totaltotal[idx] = 0;
	}

	total_length = 0;
	gccount = 0;
}

function calculate_costs (name, consarg, fixedarg, vararg, totalarg, derefarg, forwardarg, pause_length_arg) {

	# calculate the costs:

	all_objects = totalarg["co"];
	cons_objects = consarg["co"];
	fixed_objects = fixedarg["co"]
	var_objects = vararg["co"];

	real_forwards = (forwardarg - all_objects);
#print forwardarg, real_forwards, all_objects;
	cons_frac = (cons_objects / all_objects);
	fixed_frac = (fixed_objects / all_objects);
	var_frac = (var_objects / all_objects);

	# previously allocation = 6 instr per object allocated

	# calculate the costs:
	# allocation:
	#	4 instr per cons
	# 	11 instr per fixed (4 to get the vector and index)
	#	17 instr per variable (like fixed, but 6 to allocate relocatable part)

	alloc_cost = 2 * totalarg["ao"] + totalarg["aw"]

#print totalarg["ao"], alloc_cost

	a = derefarg;
	b = 0; # can't tell without count
	c = a - b;
	e = forwardarg;
	d = c - e;
        f = cons_objects + cons_frac * real_forwards;
	g = cons_objects;
	h = cons_frac * real_forwards;
#print cons_frac, real_forwards, h;
	i = consarg["co"] - consarg["po"];
	j = consarg["po"];
	e1 = g;
	k = e - f;
	l = fixed_objects + fixed_frac * real_forwards;
	m = fixed_frac * real_forwards;
	n = fixed_objects;
	o = fixedarg["co"] - fixedarg["po"];
	p = fixedarg["po"];
	e2 = n;
	q = k - l;
#	print q, (var_objects + var_frac * real_forwards)
	if ((abs(q) - abs(int((var_objects + var_frac * real_forwards)))) > 2) {
		print "var check error", q, (var_objects + var_frac * real_forwards)
		exit
	}
	r = var_frac * real_forwards;
	s = var_objects;
	t = vararg["co"] - vararg["po"];
	u = vararg["po"];
	e3 = s;
	e4 = e1 + e2 + e3;
	e5 = e4 + h + m + r;
	e6 = e5 + b + d;
	if (int(a) != int(e6)) {
		print "total check error", a, e6
		exit;
	}
	get_copy_cost = 5
	set_copy_cost = 3
	acost = 4
	bcost = 0
	ccost = 4
	dcost = 0
	ecost = 3
	fcost = 5
	gcost = get_copy_cost + 4
	hcost = 3
	icost = set_copy_cost + 2 + 3
	jcost = set_copy_cost + 4 + 3
	kcost = 3
	lcost = 5
	mcost = 3
	ncost = get_copy_cost + 4
	ocost = set_copy_cost + 2 
	pcost = set_copy_cost + 4 
	qcost = 5
	rcost = 3
	scost = get_copy_cost + 4
	tcost = set_copy_cost + 2
	ucost = set_copy_cost + 4
	e4cost = 4
	e5cost = 2
	e6cost = 4

#	print a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u;
	typeforwardcost = e * ecost + f * fcost + k * kcost + l * lcost + q * qcost;
	transportcost = g * gcost + h * hcost + i * icost + j * jcost + \
			m * mcost + n * ncost + o * ocost + p * pcost + \
			r * rcost + s * scost + t * tcost + u * ucost + \
			+ ((2 * fixedarg["cw"]) - fixedarg["co"]) + \
			+ ((4 * vararg["cw"]) - vararg["co"])
			

	scancost = a * acost + b * bcost + c * ccost + d * dcost + \
		   e6 * e6cost;
	updatecost = e4 * e4cost + e5 * e5cost;
	totalcost = alloc_cost + scancost + typeforwardcost + transportcost + updatecost;
	print name, gcstart, alloc_cost, scancost, typeforwardcost, transportcost, updatecost, totalcost, 6 * pause_length_arg;
}


BEGIN {

	initialize();

	total_forwards = 0
	total_derefs = 0;
	total_updates = 0;

}

$0 ~ /gc algorithm/ {
	algorithm = $4
}

$1 ~ /__gcbegin/ {
	togen = $2;
	gcstart = $4
	gccycle = 1;
}

(gccycle == 1) && $1 ~ /__pause_length/ {
	pause_length = $2;
}

(gccycle == 1) && $1 ~ /__cgc_forward/ {
	forwards = $2;
}

(gccycle == 1) && $1 ~ /__cgc_test/ {
	updates = $2;
}

(gccycle == 1) && $1 ~ /__cgc_deref/ {
	derefs = $2;
}

(gccycle == 1) && $1 ~ /__cwrd/ {
	update("cw");
}

(gccycle == 1) && $1 ~ /__cobj/ {
	update("co");
}

(gccycle == 1) && $1 ~ /__awrd/ {
	update("aw");
}

(gccycle == 1) && $1 ~ /__aobj/ {
	update("ao");
}

(gccycle == 1) && $1 ~ /__pobj/ {
	update("po");
}

(gccycle == 1) && $1 ~ /__pwrd/ {
	update("pw")

	gccount += 1;
	update_totals();
	check_values();
	calculate_costs("Current", cons, fixed, variable, total, derefs, forwards, pause_length);
}


END {
	check_values();
	calculate_costs("Total", totalcons, totalfixed, totalvariable, totaltotal, total_derefs, total_forwards, total_length);
}