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