/* clone a map */
GGC_Map GGC_MapClone(GGC_Map map)
{
GGC_Map ret = NULL;
GGC_MapEntryArray oldEntries = NULL, newEntries = NULL;
GGC_MapEntry oldEntry = NULL, oldNextEntry = NULL, newEntry = NULL, newNextEntry = NULL;
void *key = NULL;
void *value = NULL;
ggc_size_t size, used, i;
GGC_PUSH_10(map, ret, oldEntries, newEntries, oldEntry, oldNextEntry, newEntry, newNextEntry, key, value);
ret = GGC_NEW(GGC_Map);
/* if it's empty, no further work */
if (GGC_RD(map, size) == 0) return ret;
/* copy the basic info */
size = GGC_RD(map, size);
used = GGC_RD(map, used);
oldEntries = GGC_RP(map, entries);
GGC_WD(ret, size, size);
GGC_WD(ret, used, used);
/* copy all the entries */
newEntries = GGC_NEW_PA(GGC_MapEntry, size);
for (i = 0; i < size; i++) {
oldEntry = GGC_RAP(oldEntries, i);
if (oldEntry) {
newEntry = GGC_NEW(GGC_MapEntry);
GGC_WAP(newEntries, i, newEntry);
while (oldEntry) {
oldNextEntry = GGC_RP(oldEntry, next);
if (oldNextEntry)
newNextEntry = GGC_NEW(GGC_MapEntry);
else
newNextEntry = NULL;
GGC_WP(newEntry, next, newNextEntry);
key = GGC_RP(oldEntry, key);
GGC_WP(newEntry, key, key);
value = GGC_RP(oldEntry, value);
GGC_WP(newEntry, value, value);
oldEntry = oldNextEntry;
newEntry = newNextEntry;
}
}
}
GGC_WP(ret, entries, newEntries);
return ret;
}
int ggc_thread_create(ggc_thread_t *thread, void (*func)(ThreadArg), ThreadArg arg)
{
ThreadInfo ti = NULL;
GGC_PUSH_2(arg, ti);
/* set up its thread info */
ti = GGC_NEW(ThreadInfo);
GGC_WD(ti, func, func);
GGC_WP(ti, arg, arg);
/* update our thread barrier */
while (ggc_mutex_trylock(&ggggc_worldBarrierLock) != 0)
GGC_YIELD();
if (ggggc_threadCount == 0) ggggc_threadCount++;
else ggc_barrier_destroy(&ggggc_worldBarrier);
ggc_barrier_init(&ggggc_worldBarrier, ++ggggc_threadCount);
ggc_mutex_unlock(&ggggc_worldBarrierLock);
/* spawn the pthread */
if ((errno = pthread_create(thread, NULL, ggggcThreadWrapper, ti)))
return -1;
return 0;
}
int main(void)
{
int i, j, last, cur;
TWO head = NULL, end = NULL, node = NULL;
GGC_PUSH_3(node, end, head);
head = GGC_NEW(TWO);
GGC_WD(head, val, 0);
end = head;
/* create list */
for (i = 1; i < 4096; i++) {
/* create garbage */
for (j = 0; j < 4096; j++) {
node = GGC_NEW(TWO);
}
node = GGC_NEW(TWO);
GGC_WD(node, val, i);
GGC_WP(end, next, node);
end = node;
}
/* check list */
last = GGC_RD(head, val);
node = GGC_RP(head, next);
while (node) {
cur = GGC_RD(node, val);
if (cur == (last + 1)) {
last = cur;
node = GGC_RP(node, next);
}
else {
printf("WRONG\n");
exit(1);
}
}
return 0;
}
treeNode NewTreeNode(treeNode left, treeNode right, long item)
{
treeNode newT = NULL;
GGC_PUSH_3(left, right, newT);
newT = GGC_NEW(treeNode);
GGC_WP(newT, left, left);
GGC_WP(newT, right, right);
GGC_WD(newT, item, item);
return newT;
} /* NewTreeNode() */
LLL buildLLL(int sz)
{
int i;
LLL ll0 = NULL, lll = NULL, llc = NULL;
GGC_PUSH_3(ll0, lll, llc);
printf("calling malloc\n");
ll0 = GGC_NEW(LLL);
printf("here obj is %u\n",ll0);
GGC_WD(ll0, val, 0);
lll = ll0;
for (i = 1; i < sz; i++) {
llc = GGC_NEW(LLL);
//printf("here obj is %zu\n",llc);
GGC_WD(llc, val, i);
GGC_WP(lll, next, llc);
lll = llc;
GGC_YIELD();
}
return ll0;
}
/* put an element in a map */
void GGC_MapPut(GGC_Map map, void *key, void *value, ggc_map_hash_t hash, ggc_map_cmp_t cmp)
{
void *keyCmp = NULL;
void *valueCmp = NULL;
GGC_MapEntry entry = NULL, nextEntry = NULL, prevEntry = NULL;
GGC_MapEntryArray newEntries = NULL;
size_t hashV;
ggc_size_t newSize, newUsed, i;
GGC_PUSH_9(map, key, value, keyCmp, valueCmp, entry, nextEntry, prevEntry,
newEntries);
if (GGC_RD(map, size) == 0) {
/* start with something */
GGC_WD(map, size, 4);
newEntries = GGC_NEW_PA(GGC_MapEntry, 4);
GGC_WP(map, entries, newEntries);
}
newUsed = GGC_RD(map, used);
if (newUsed > GGC_RD(map, size) / 2) {
/* the hash is getting full. Expand it */
newSize = GGC_RD(map, size) * 2;
newEntries = GGC_NEW_PA(GGC_MapEntry, newSize);
for (i = 0; i < GGC_RD(map, size); i++) {
entry = GGC_RAP(GGC_RP(map, entries), i);
while (entry) {
nextEntry = GGC_RP(entry, next);
keyCmp = GGC_RP(entry, key);
hashV = hash(keyCmp) % newSize;
prevEntry = GGC_RAP(newEntries, hashV);
GGC_WP(entry, next, prevEntry);
GGC_WAP(newEntries, hashV, entry);
entry = nextEntry;
}
}
GGC_WD(map, size, newSize);
GGC_WP(map, entries, newEntries);
}
/* figure out where to put it */
hashV = hash(key) % GGC_RD(map, size);
/* look over current entries */
entry = GGC_RAP(GGC_RP(map, entries), hashV);
while (entry) {
/* entry found. Does it match? */
keyCmp = GGC_RP(entry, key);
if (cmp(key, keyCmp) == 0) {
/* yes. Just update the value */
GGC_WP(entry, value, value);
return;
}
entry = GGC_RP(entry, next);
}
/* didn't find a current entry. Make a new one */
newEntries = GGC_RP(map, entries);
entry = GGC_NEW(GGC_MapEntry);
nextEntry = GGC_RAP(newEntries, hashV);
GGC_WP(entry, next, nextEntry);
GGC_WP(entry, key, key);
GGC_WP(entry, value, value);
GGC_WAP(newEntries, hashV, entry);
/* and keep track of our use */
newUsed++;
GGC_WD(map, used, newUsed);
return;
}
