BOOL templAssign(unsigned argc, char *argv[])
{
ADDR adr, tadr;
REG val, tval;
Bundle bndl;
BYTE templ;
REG datamask = ONES(5);
unsigned i;
BOOL ret = YES;
if (!evalExpr(argv[0], HEXEXP, &adr))
return NO;
if (adr != (tadr = adr & ~(ADDR)0xf)) {
adr = tadr;
cmdWarn("Non bundle-aligned address. Aligned to 0x%llx\n", adr);
}
for (i = 1; i < argc; i++, adr += 16) {
if (asm_templ(argv[i], &templ) == AsmOK)
val = templ;
else if (!evalExpr(argv[i], HEXEXP, &val))
continue;
if (val != (tval = val & datamask)) {
val = tval;
cmdWarn("Data larger than 0x1f. Truncated to 0x%llx\n", val);
}
templ = (BYTE)val;
if (!memMIRd(adr, (DWORD *)&bndl)) {
cmdWarn("Assignment failed\n");
continue;
}
templReplace(&bndl, adr, templ);
(void)memMIWrt(adr, (DWORD *)&bndl);
}
if (i != argc) {
cmdErr("Some values could not be assigned\n");
ret = NO;
}
prgwUpdate();
datwUpdate();
return ret;
}
/*---------------------------------------------------------------------------
* memory$Assign - Assign specified data items of specified 'size' to memory
* starting with the given address.
*---------------------------------------------------------------------------*/
static BOOL memAssign(unsigned argc, char *argv[], unsigned size)
{
ADDR adr, tadr;
REG val, tval;
REG adrmask = size - 1;
REG datamask = ONES(size*8);
unsigned i;
BOOL ret = YES;
static const char sizestr[][12] = {
"0 ?", "byte", "halfword",
"3 ?", "word", "5 ?",
"6 ?", "7 ?", "doubleword"
};
if (!evalExpr(argv[0], HEXEXP, &adr))
return NO;
if (adr != (tadr = adr & ~adrmask)) {
adr = tadr;
cmdWarn("Non %s-aligned address. Aligned to 0x%llx\n",
sizestr[size], adr);
}
for (i = 1; i < argc; i++, adr += size) {
if (!evalExpr(argv[i], HEXEXP, &val))
break;
if (val != (tval = val & datamask)) {
val = tval;
cmdWarn("Data larger than %d byte%s. Truncated to 0x%llx\n",
size, size > 1 ? "s" : "", val);
}
if (!memMWrt(adr, size, val))
cmdWarn("Assignment to address %llx failed\n", adr);
}
if (i != argc) {
cmdErr("Some values could not be assigned\n");
ret = NO;
}
prgwUpdate();
datwUpdate();
return ret;
}
void scalefree(edge *g, agent *a) {
edge ne = 1;
agent deg[N] = {0};
for (agent i = 1; i <= M; i++) {
for (agent j = 0; j < i; j++) {
createedge(g, a, i, j, ne);
deg[i]++;
deg[j]++;
ne++;
}
}
chunk t[C] = { 0 }, t1[C] = { 0 };
for (agent i = M + 1; i < N; i++) {
ONES(t1, i, C);
MASKANDNOT(t, t1, t, C);
for (agent j = 0; j < M; j++) {
agent d = 0;
for (agent h = 0; h < i; h++)
if (!GET(t, h)) d += deg[h];
if (d > 0) {
int p = nextInt(d);
agent q = 0;
while (p >= 0) {
if (!GET(t, q)) p = p - deg[q];
q++;
}
q--;
SET(t, q);
createedge(g, a, i, q, ne);
deg[i]++;
deg[q]++;
ne++;
}
}
}
}
BOOL instrAssign(unsigned argc, char *argv[])
{
ADDR adr, tadr;
REG val, tval;
REG datamask = ONES(41);
unsigned i, slot;
BOOL ret = YES;
Bundle bndl;
InstID instID;
Operands ops;
EncodedInst inst;
if (!evalExpr(argv[0], HEXEXP, &adr))
return NO;
if ((slot = SLOT(adr)) > 2) {
cmdErr("Illegal slot field in instruction address\n");
return NO;
}
if (adr != (tadr = adr & ~(ADDR)0x3)) {
adr = tadr;
cmdWarn("Non slot-aligned address. Aligned to 0x%llx\n", adr);
}
badr = adr & ~(ADDR)0xf; /* bundle-align address */
for (i = 1; i < argc; i++, slot++) {
if (slot >= SLOTS_PER_BUNDLE) {
slot = 0;
badr += 16;
}
if (asm_inst(argv[i], &instID, &ops, &inst) != AsmOK) {
if (evalExpr(argv[i], HEXEXP, &val)) {
if (val != (tval = val & datamask)) {
val = tval;
cmdWarn("Data larger than 41 bits. Truncated to 0x%llx\n",
val);
}
inst.bits = val;
inst.unit = No_Unit;
inst.valid_extra_bits = 0;
} else
break;
}
if (!memMIRd(badr, (DWORD *)&bndl)) {
cmdWarn("Assignment failed\n");
continue;
}
if (!instrReplace(&bndl, badr, slot, &inst)) {
cmdWarn("That instruction not allowed in that slot\n");
continue;
}
(void)memMIWrt(badr, (DWORD *)&bndl);
if (inst.valid_extra_bits)
slot++;
}
if (i != argc) {
cmdErr("Some values could not be assigned\n");
ret = NO;
}
prgwUpdate();
datwUpdate();
return ret;
}
/*---------------------------------------------------------------------------
* value$Assign - Assign the user specified value to the user-specifed
* internal symbol.
*---------------------------------------------------------------------------*/
BOOL valAssign(unsigned argc, char *argv[])
{
struct isym *psym, sym;
REG val;
if (!(psym = isymVLkp(argv[0]))) {
cmdErr("Unrecognized symbol name: %s\n", argv[0]);
return NO;
}
sym = *psym;
if (!evalExpr(argv[1], psym->dbase, &val))
return NO;
switch (sym.type) {
case SINGLE_SYM:
if (sym.setFn) {
if (!sym.setFn(0, val)) {
cmdErr("Attempt to modify symbol failed\n");
return NO;
}
} else {
cmdWarn("Ignored attempt to write a Read-Only symbol\n");
return NO;
}
break;
case REGSET_SYM:
if (sym.setFn) {
if (!sym.setFn(0, sym.ndx, val)) {
cmdErr("Attempt to modify symbol failed\n");
return NO;
}
} else {
cmdWarn("Ignored attempt to write a Read-Only symbol\n");
return NO;
}
break;
case BITF_SYM:
if (sym.setFn) {
REG oldval = sym.getFn(0), mask;
mask = ONES(sym.len) << (sym.start - (sym.len - 1));
val <<= sym.start - (sym.len - 1);
val = (oldval & ~mask) | (val & mask);
if (!sym.setFn(0, val)) {
cmdErr("Attempt to modify symbol failed\n");
return NO;
}
} else {
cmdWarn("Ignored attempt to write a Read-Only symbol\n");
return NO;
}
break;
case RS_BITF_SYM:
if (sym.setFn) {
REG oldval = sym.getFn(0, sym.ndx), mask;
mask = ONES(sym.len) << (sym.start - (sym.len - 1));
val <<= sym.start - (sym.len - 1);
val = (oldval & ~mask) | (val & mask);
if (!sym.setFn(0, sym.ndx, val)) {
cmdErr("Attempt to modify symbol failed\n");
return NO;
}
} else {
cmdWarn("Ignored attempt to write a Read-Only symbol\n");
return NO;
}
break;
default:
break;
}
setDerivedState(1);
prgwPCRedraw();
datwUpdate();
regwUpdate();
return YES;
}
0xffffffff, /* Source mask. */
0xffffffff, /* Dest mask. */
FALSE), /* PCrel_offset. */
/* A 64 bit reference to a symbol. */
HOWTO (ALPHA_R_REFQUAD, /* Type. */
0, /* Rightshift. */
4, /* Size (0 = byte, 1 = short, 2 = long). */
64, /* Bitsize. */
FALSE, /* PC_relative. */
0, /* Bitpos. */
complain_overflow_bitfield, /* Complain_on_overflow. */
0, /* Special_function. */
"REFQUAD", /* Name. */
TRUE, /* Partial_inplace. */
ONES (64), /* Source mask. */
ONES (64), /* Dest mask. */
FALSE), /* PCrel_offset. */
/* A 32 bit GP relative offset. This is just like REFLONG except
that when the value is used the value of the gp register will be
added in. */
HOWTO (ALPHA_R_GPREL32, /* Type. */
0, /* Rightshift. */
2, /* Size (0 = byte, 1 = short, 2 = long). */
32, /* Bitsize. */
FALSE, /* PC_relative. */
0, /* Bitpos. */
complain_overflow_bitfield, /* Complain_on_overflow. */
0, /* Special_function. */
"GPREL32", /* Name. */
int main(int argc, char *argv[]) {
// Allocate stack
stack st[N];
// Create shortest paths matrix
const unsigned seed = atoi(argv[1]);
st->sp = createsp(seed);
// Generate random set of drivers
for (agent i = 0; i < D; i++)
st->dr[i] = 1;
memset(st->dr + D, 0, sizeof(agent) * (N - D));
shuffle(st->dr, N, sizeof(agent));
memcpy(drg, st->dr, N * sizeof(agent));
// Initialise n, s, and cs data structures
st->n[N] = N;
for (agent i = 0; i < N; i++) {
X(sg, i) = X(st->s, i) = 1;
Y(sg, i) = Y(st->s, i) = csg[i] = st->cs[i] = i;
st->l[i] = st->sp[4 * i * N + 2 * i + 1];
min += COST(i, st->dr, st->l);
st->n[st->n[i] = N + i + 1] = i;
}
// Initialise c and r bitmasks
ONES(st->c, E + 1, C);
CLEAR(st->c, 0);
ONES(st->r, E + 1, C);
CLEAR(st->r, 0);
// Create graph
#ifdef M
init(seed);
memset(st->g, 0, sizeof(edge) * N * N);
scalefree(st->g, st->a);
#else
FILE *f = fopen(argv[2], "r");
for (agent e = 1; e <= E; e++) {
agent v1, v2;
fscanf(f, "%u %u", &v1, &v2);
createedge(st->g, st->a, v1, v2, e);
}
fclose(f);
#endif
// Reorder (eventually)
#ifdef REORDER
edge go[N * N] = {0};
agent ao[2 * (E + 1)];
#ifdef METIS
idx_t options[METIS_NOPTIONS];
METIS_SetDefaultOptions(options);
options[METIS_OPTION_OBJTYPE] = METIS_OBJTYPE_CUT;
options[METIS_OPTION_SEED] = seed;
real_t tpwgts[2] = {0.5, 0.5}, ubvec = TOLERANCE;
agent map[N];
edge e = 1;
for (agent i = 0; i < N; i++) map[i] = i;
reorderedges(st->g, map, N, E, go, ao, &e, tpwgts, &ubvec, options);
#else
driversbfs(st->a, st->dr, go, ao);
#endif
memcpy(st->g, go, sizeof(edge) * N * N);
memcpy(st->a, ao, sizeof(agent) * 2 * (E + 1));
#endif
#ifdef TREEDOT
st->dot = fopen(TREEDOT, "w+");
fprintf(st->dot, "digraph TREE {\n");
fprintf(st->dot, "\tnode [color = none; shape = plaintext, width = 0.2, height = 0.2];\n");
#endif
// Solve
sol = *st;
#ifdef LIMIT
value bou = bound(st);
#endif
gettimeofday(&t1, NULL);
srcfss(st, min);
gettimeofday(&t2, NULL);
// Print solution
#ifdef TREEDOT
printf("SOLUTION = %zu\n", sol.id);
fprintf(st->dot, "\t%zu [shape = circle, style = filled, fillcolor = green];\n", sol.id);
#endif
#ifdef PK
FILE *pk = fopen(PK, "w+");
fprintf(pk, "%u\n%u\n%u\n", N, K, seed);
printg(st->g, pk);
printpk(&sol, pk);
fclose(pk);
#endif
#ifdef CSV
printf("%u,%u,%s,%.2f,%f,%zu\n", N, E, argv[1], 0.01 * min,
(double)(t2.tv_usec - t1.tv_usec) / 1e6 + t2.tv_sec - t1.tv_sec, count);
#else
printcs(&sol);
printf("Visited nodes = %zu\n", count);
printf("Elapsed time = %f\n", (double)(t2.tv_usec - t1.tv_usec) / 1e6 + t2.tv_sec - t1.tv_sec);
printf("Solution = %.2f€\n", 0.01 * min);
#ifdef LIMIT
printf("Bound = %.2f€\n", 0.01 * bou);
#endif
#endif
// Free data structures
#ifdef TREEDOT
fprintf(st->dot, "}");
fclose(st->dot);
#endif
free(st->sp);
return 0;
}
