Node *createSingleNode(int Num, int NumBlanks)
{
#if defined(_USE_MALLOC)
Node *node = (Node *) malloc(sizeof(Node));
#else
Node *node = (Node *) nvm_alloc(sizeof(Node), sll_rgn_id);
#endif
int num_digits = log10(Num)+1;
int len = num_digits+NumBlanks;
#if defined(_USE_MALLOC)
char* d = (char*) malloc((len+1)*sizeof(char));
#else
char* d = (char*) nvm_alloc((len+1)*sizeof(char), sll_rgn_id);
#endif
NVM_STR2(node->Data, d, sizeof(char*)*8);
char *tmp_s = (char *) alloca(
(num_digits > NumBlanks ? num_digits+1 : NumBlanks+1)*sizeof(char));
sprintf(tmp_s, "%d", Num);
NVM_MEMCPY(node->Data, tmp_s, num_digits);
for (int i = 0; i < NumBlanks; ++i) tmp_s[i] = ' ';
NVM_MEMCPY(node->Data + num_digits, tmp_s, NumBlanks);
NVM_STR2(node->Data[num_digits+NumBlanks], '\0', sizeof(char)*8);
return node;
}
Node *insertPass2(int Num, int NumBlanks, int NumFAI)
{
Node** new_nodes = (Node**) malloc (NumFAI*sizeof(Node*));
Node* list_iter = InsertAfter->Next;
for (int i=0; i < NumFAI; i++)
{
new_nodes[i] = createSingleNode(Num + i, NumBlanks);
if (list_iter != NULL)
{
NVM_STR2(new_nodes[i]->Next, list_iter, sizeof(list_iter)*8);
}
else
break;
list_iter = list_iter->Next;
}
NVM_BEGIN_DURABLE();
for (int i=0; i < NumFAI; i++)
{
NVM_STR2(InsertAfter->Next, new_nodes[i], sizeof(InsertAfter->Next)*8);
if (new_nodes[i]->Next != NULL)
InsertAfter = new_nodes[i]->Next;
else
{
InsertAfter = new_nodes[i];
break;
}
}
NVM_END_DURABLE();
return InsertAfter;
}
void initialize()
{
void * rgn_root = NVM_GetRegionRoot(queue_rgn_id);
if (rgn_root)
{
Q = (queue_t *)rgn_root;
Q->head_lock = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(Q->head_lock, NULL);
Q->tail_lock = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(Q->tail_lock, NULL);
fprintf(stderr, "Found queue at %p\n", Q);
traverse();
}
else
{
node_t * node =
#if defined(_USE_MALLOC)
(node_t *) malloc(sizeof(node_t));
#else
(node_t *) nvm_alloc(sizeof(node_t), queue_rgn_id);
#endif
assert(node);
NVM_STR2(node->val, -1, sizeof(int)*8); // dummy value
NVM_STR2(node->next, NULL, sizeof(node_t*)*8);
#if defined(_USE_MALLOC)
Q = (queue_t *) malloc(sizeof(queue_t));
#else
Q = (queue_t *) nvm_alloc(sizeof(queue_t), queue_rgn_id);
#endif
assert(Q);
fprintf(stderr, "Created Q at %p\n", Q);
Q->head_lock = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(Q->head_lock, NULL);
Q->tail_lock = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(Q->tail_lock, NULL);
NVM_BEGIN_DURABLE();
NVM_STR2(Q->head, node, sizeof(node_t*)*8);
NVM_STR2(Q->tail, node, sizeof(node_t*)*8);
NVM_SetRegionRoot(queue_rgn_id, Q);
NVM_END_DURABLE();
}
}
int dequeue(int *valp) {
NVM_LOCK(*(Q->head_lock));
// note that not everything of type node_t is persistent
// In the following statement, we have a transient pointer to
// persistent data which is just fine. If there is a crash, the
// transient pointer goes away.
node_t *node = Q->head;
node_t *new_head = node->next;
if (new_head == NULL) {
NVM_UNLOCK(*(Q->head_lock));
return 0;
}
*valp = new_head->val;
#ifdef _FORCE_FAIL
if (*valp == NUM_ITEMS / 4)
exit(0);
#endif
NVM_STR2(Q->head, new_head, sizeof(node_t *) * 8);
NVM_UNLOCK(*(Q->head_lock));
#if defined(_USE_MALLOC)
free(node);
#else
nvm_free(node);
#endif
return 1;
}
Node *insertPass1(int Num, int NumBlanks, int NumFAI) {
Node *node = createSingleNode(Num, NumBlanks);
// In pass 1, the new node is the last node in the list
NVM_STR2(node->Next, NULL, sizeof(node->Next) * 8);
NVM_BEGIN_DURABLE();
if (!SLL) {
NVM_STR2(SLL, node, sizeof(SLL) * 8); // write-once
InsertAfter = node;
} else {
NVM_STR2(InsertAfter->Next, node, sizeof(InsertAfter->Next) * 8);
InsertAfter = node;
}
NVM_END_DURABLE();
return node;
}
void enqueue(int val) {
node_t *node =
#if defined(_USE_MALLOC)
(node_t *)malloc(sizeof(node_t));
#else
(node_t *)nvm_alloc(sizeof(node_t), queue_rgn_id);
#endif
assert(node);
NVM_STR2(node->val, val, sizeof(int) * 8);
NVM_STR2(node->next, NULL, sizeof(node_t *) * 8);
NVM_LOCK(*(Q->tail_lock));
NVM_STR2(Q->tail->next, node, sizeof(node_t *) * 8);
#ifdef _FORCE_FAIL
if (val == NUM_ITEMS / 2)
exit(0);
#endif
NVM_STR2(Q->tail, node, sizeof(node_t *) * 8);
NVM_UNLOCK(*(Q->tail_lock));
}
