bool ColorProvider::compareAndSet(Range<float>& toSet,
const float min,
const float max)
{
return compareAndSet(toSet.min, min) |
compareAndSet(toSet.max, max);
}
bool ColorProvider::compareAndSet(ColorReference::HSVColorDefinition& toSet,
const float minH, const float maxH,
const float minS, const float maxS,
const float minV, const float maxV)
{
return compareAndSet(toSet.hue, minH, maxH) |
compareAndSet(toSet.saturation, minS, maxS) |
compareAndSet(toSet.value, minV, maxV);
}
bool donate(int threadId, Chunk *chunk) {
LOG_PROLOG();
//LOG_INFO("donate: threadID %d\n", threadId);
int i = (getDonorEntry(threadId)->lastDonated + 1) % (memory->n);
bool *tempBoolObj;
assert(globalHPStructure->topPointers[threadId] == 0);
do {
LOG_INFO("donate: trying to donate to %d", i);
ReferenceIntegerPair *announceOfThreadToBeHelped = setHazardPointer(globalHPStructure, threadId, getHelperEntry(i)->atomicRef);
ReferenceIntegerPair *oldTop = setHazardPointer(globalHPStructure, threadId, GET_STACK_THREAD(memory->fullPool, i)->stack->top->atomicRef);
assert(globalHPStructure->topPointers[threadId] == 2);
// int oldTS = announceOfThreadToBeHelped->integer;
if ((*(bool*)announceOfThreadToBeHelped->reference == true) && (GET_STACK_THREAD(memory->fullPool, i)->stack->top->atomicRef->reference == NULL) && (getHelperEntry(i)->atomicRef->integer == announceOfThreadToBeHelped->integer)) {
LOG_INFO("donate: %d needed help", i);
if (putInOtherFullPool(memory->fullPool, i, chunk, oldTop, threadId)) {
assert(globalHPStructure->topPointers[threadId] == 1);
LOG_INFO("donate: successfully donated to %d", i);
tempBoolObj = (bool*)my_malloc(sizeof(bool));
*tempBoolObj = false;
if(!compareAndSet(getHelperEntry(i),announceOfThreadToBeHelped->reference, tempBoolObj, announceOfThreadToBeHelped->integer, (announceOfThreadToBeHelped->integer + 1), threadId)) {
//clearHazardPointer(globalHPStructure, threadId);
my_free(tempBoolObj);
}
assert(globalHPStructure->topPointers[threadId] == 0);
getDonorEntry(threadId)->lastDonated = i;
LOG_EPILOG();
return true;
}
LOG_INFO("donate: donation to %d failed: someone else helped", i);
//getHelperEntry(i)->compareAndSet(...);
tempBoolObj = (bool*)my_malloc(sizeof(bool));
*tempBoolObj = false;
if (!compareAndSet(getHelperEntry(i),announceOfThreadToBeHelped->reference, tempBoolObj, announceOfThreadToBeHelped->integer, (announceOfThreadToBeHelped->integer + 1), threadId)) {
//clearHazardPointer(globalHPStructure, threadId);
my_free(tempBoolObj);
}
assert(globalHPStructure->topPointers[threadId] == 0);
}
else {
clearHazardPointer(globalHPStructure, threadId);
clearHazardPointer(globalHPStructure, threadId);
LOG_INFO("donate: clearing HP of thread. Donation was not needed");
}
i = (i + 1) % (memory->n);
assert(globalHPStructure->topPointers[threadId] == 0);
} while(i != (getDonorEntry(threadId)->lastDonated + 1) % (memory->n));
LOG_EPILOG();
return false;
}
void* stackPopOther(Stack* stack, int threadIndex)
{
LOG_PROLOG();
void *ptr = NULL;if (stack->top->atomicRef->reference == NULL) {
ptr = NULL;
}
else {
ReferenceIntegerPair *oldTop = setHazardPointer(globalHPStructure, threadIndex, stack->top->atomicRef);
StackElement *copy = (StackElement*)(oldTop->reference);
StackElement *nextTopReference = ((StackElement*)(oldTop->reference))->next;
if (nextTopReference == NULL) {
clearHazardPointer(globalHPStructure, threadIndex);
ptr = NULL;
}
else if (compareAndSet(stack->top, oldTop->reference, ((StackElement*)oldTop->reference)->next, oldTop->integer, (oldTop->integer + 1), threadIndex)) {
void* poppedItem = ((StackElement*)oldTop->reference)->value;
LOG_INFO("stackPopOther: threadid = %d inside CAS \n", threadIndex);
my_free(copy);
ptr = poppedItem;
}
else
{
LOG_INFO("stackPopOther: CAS failed\n");
ptr = NULL;
}
}
LOG_EPILOG();
return ptr;
}
void* stackPopOwner(Stack* stack, int threadId)
{
LOG_PROLOG();
void *ptr = NULL;
ReferenceIntegerPair *oldTop = setHazardPointer(globalHPStructure, threadId, stack->top->atomicRef);
if(stack->top->atomicRef->reference == NULL){
LOG_INFO("stackPopOwner: stack was empty\n");
ptr = NULL;
}
else {
void *oldValue = ((StackElement*)oldTop->reference)->value;
StackElement *copy = (StackElement*)(oldTop->reference);
StackElement *nextTopReference = ((StackElement*)(oldTop->reference))->next;
if (compareAndSet(stack->top, oldTop->reference, nextTopReference, oldTop->integer, (oldTop->integer+1), threadId)) {
my_free(copy);
ptr = oldValue;
}
else {
//clearHazardPointer(globalHPStructure, threadId);
LOG_INFO("stackPopOwner: CAS failed");
ptr = NULL;
}
}
LOG_EPILOG();
return ptr;
}
long getCountChange() {
long c;
bool ret;
do {
c = getCount();
ret = compareAndSet(c, 0);
} while(!ret);
return c;
}
bool stackPushOther(Stack *stack, void* element, ReferenceIntegerPair* oldTop, int threadId)
{
LOG_PROLOG();
StackElement *node = (StackElement*)my_malloc(sizeof(StackElement));
node->value = element;
node->next = (StackElement*)stack->top->atomicRef->reference;
bool flag = compareAndSet(stack->top, NULL, node, oldTop->integer, (oldTop->integer + 1), threadId);
LOG_EPILOG();
return flag;
}
bool stackPushOwner(Stack *stack, void* element, int threadId)
{
LOG_PROLOG();
StackElement *node = (StackElement*)my_malloc(sizeof(StackElement));
node->value = element;
node->next = (StackElement*)stack->top->atomicRef->reference;
//LOG_INFO("stackPushOwner before setting HP\n");
LOG_INFO("global Structure is %u", globalHPStructure);
ReferenceIntegerPair *oldTop = setHazardPointer(globalHPStructure, threadId, stack->top->atomicRef);
bool flag = compareAndSet(stack->top, oldTop->reference, node, oldTop->integer, (oldTop->integer + 1), threadId);
LOG_EPILOG();
return flag;
}
/* Test vararg list of arguments searching for the smallest, store it and return.
* On next excustion smallest found from previous iteration will be used as
* basis for the searching operation.
*
* Input values will be valid int numbers (guranteed by forum post).
*/
int min_value(int val1, ...) {
static int minimumFoundSoFar = INT_MAX;
va_list ap;
int candidate;
/* Initialize the var_args macros subsystem. */
va_start(ap, val1);
/* Initialize the loop. */
candidate = val1;
/* Iterate over the list of supplied arguments. */
while(LIST_TERMINATOR != candidate) {
compareAndSet(&minimumFoundSoFar, candidate);
/* fetch next argument. */
candidate = va_arg(ap, int);
}
/* Cleanup for va_* macro subsystem. */
va_end(ap);
/* return the smallest number found. */
return minimumFoundSoFar;
}
//Chunk* doHelp(int threadToBeHelped, Chunk *stolenChunk, Helper *announceOfThreadToBeHelped) {
Chunk* doHelp(int threadId, int threadToBeHelped, Chunk *stolenChunk, ReferenceIntegerPair *announceOfThreadToBeHelped) {
LOG_PROLOG();
assert(globalHPStructure->topPointers[threadId] == 1);
int i = 0;
//LOG_INFO("doHelp: threadId: %d\n",threadId);
//LOG_INFO("doHelp: threadId: %d, current annTS: %d, old annTS: %d\n",threadId,getHelperEntry(threadToBeHelped)->atomicRef->integer,announceOfThreadToBeHelped->atomicRef->integer);
//if (getHelperEntry(threadToBeHelped)->timestamp != announceOfThreadToBeHelped->timestamp)
if (getHelperEntry(threadToBeHelped)->atomicRef->integer != announceOfThreadToBeHelped->integer) {
LOG_INFO("doHelp: somebody already helped threadToBeHelped = %d", threadToBeHelped);
clearHazardPointer(globalHPStructure, threadId);
LOG_EPILOG();
return stolenChunk;
}
if (stolenChunk == NULL) {
LOG_INFO("doHelp: stolenChunk is null");
//LOG_INFO("doHelp: threadId %d, top reference = %u\n", threadId, getStackThread(memory->fullPool, threadToBeHelped)->stack->top->atomicRef->reference);
//LOG_INFO("doHelp: threadId %d, current annTS = %d, old annTS = %d\n",threadId, getHelperEntry(threadToBeHelped)->atomicRef->integer, announceOfThreadToBeHelped->atomicRef->integer);
assert(globalHPStructure->topPointers[threadId] == 1);
while ((GET_STACK_THREAD(memory->fullPool, threadToBeHelped)->stack->top->atomicRef->reference == NULL) && (getHelperEntry(threadToBeHelped)->atomicRef->integer == announceOfThreadToBeHelped->integer)) {
//LOG_INFO("doHelp: inside while");
stolenChunk = getFromOtherFullPool(memory->fullPool, i, threadId);
LOG_INFO("doHelp: victim = %d",i);
if (stolenChunk != NULL) {
LOG_INFO("stealAttempt successful");
break;
}
//LOG_INFO("doHelp: dtealAttempt failed\n");
i = (i + 1) % memory->n;
if (i == 0) {
assert(globalHPStructure->topPointers[threadId] == 1);
stolenChunk = moveFromSharedQueuePools(threadId);
//LOG_INFO("doHelp: treadId = %d, topPtr value = %d\n", threadId, globalHPStructure->topPointers[threadId]);
assert(globalHPStructure->topPointers[threadId] == 1);
//LOG_INFO("allocate: threadID : %d, returned from moveFreomSQP with stolenChunk %u\n", threadId, stolenChunk);
if (stolenChunk != NULL) {
LOG_INFO("!!!!!!!!!!!!!!got a chunk from SQP");
break;
}
LOG_INFO("doHelp: returned from moveFreomSQP");
}
}
}
assert(globalHPStructure->topPointers[threadId] == 1);
ReferenceIntegerPair *oldTop = setHazardPointer(globalHPStructure, threadId, GET_STACK_THREAD(memory->fullPool, threadToBeHelped)->stack->top->atomicRef);
//LOG_INFO("doHelp: setting HP of thread %d for oldTop %u\n", threadId, oldTop);
assert(globalHPStructure->topPointers[threadId] == 2);
bool *tempBoolObj;
if ((GET_STACK_THREAD(memory->fullPool, threadToBeHelped)->stack->top->atomicRef->reference == NULL) && (getHelperEntry(threadToBeHelped)->atomicRef->integer == announceOfThreadToBeHelped->integer)) {
assert(globalHPStructure->topPointers[threadId] == 2);
if (putInOtherFullPool(memory->fullPool, threadToBeHelped, stolenChunk, oldTop, threadId)) {
LOG_INFO("successfully helped thread %d", threadToBeHelped);
assert(globalHPStructure->topPointers[threadId] == 1);
tempBoolObj = (bool*)my_malloc(sizeof(bool));
*tempBoolObj = false;
if (!compareAndSet(getHelperEntry(threadToBeHelped),announceOfThreadToBeHelped->reference, tempBoolObj, announceOfThreadToBeHelped->integer, (announceOfThreadToBeHelped->integer + 1), threadId)) {
//LOG_INFO("doHelp: thread = %d, removing HP from annouce\n", threadId);
my_free(tempBoolObj);
}
LOG_EPILOG();
return NULL;
}
}
else {
assert(globalHPStructure->topPointers[threadId] == 2);
clearHazardPointer(globalHPStructure, threadId);
assert(globalHPStructure->topPointers[threadId] == 1);
//LOG_INFO("doHelp: clearing HP of top thread %d when someone else helped\n", threadId);
}
LOG_INFO("thread %d already got help",threadToBeHelped);
tempBoolObj = (bool*)my_malloc(sizeof(bool));
*tempBoolObj = false;
if (!compareAndSet(getHelperEntry(threadToBeHelped),announceOfThreadToBeHelped->reference, tempBoolObj, announceOfThreadToBeHelped->integer, (announceOfThreadToBeHelped->integer + 1), threadId)) {
my_free(tempBoolObj);
}
assert(globalHPStructure->topPointers[threadId] == 0);
LOG_EPILOG();
return stolenChunk;
}
