Modifying *int[] passed as a parameter - c

Question

My problem has to do with passing an array of integers to a function by passing the array's address. The integer array functions properly outside the function, but not inside. Most of what I've written up is just to give some extra details that may or may not be useful. To get the real gist of the problem you can skip to TL;DR at the bottom.
There are two structs:
lineType is a struct consisting of two integer values (valid and tag)
typedef struct
{
int valid;
int tag;
} lineType;
setType is a struct consisting of a pointer to a grouping of lines and a pointer to a grouping of integers.
typedef struct
{
lineType * lines;
int * iruQueue;
}
I have a pointer to a grouping of setTypes called cache (for anyone familiar with computer systems, this object is used to represent a cache system. A cache has a number of sets, each with a number of lines containing a tag, a bit indicating whether or not the line holds valid information, and a byte offset for the actual information the line holds. None of this is really required for my main question, but I thought this might clarify what I am attempting to do).
So we have setType * cache.
I have created a function that will allocate the proper space for the cache called initCache. Again, not sure if this information is necessary, but I want to throw out all the detail I can.
setType * initCache(int NoSets, int NoLines)
int i, j;
setType * cache;
//allocates the appropriate space for the sets
cache = malloc(sizeof(setType) * NoSets);
for(i = 0; i < NoSets; i++)
{
//allocates the space for the lines and the integer array
cache[i].lines = malloc(sizeof(lineType) * NoLines);
cache[i].iruQueue = malloc(sizeof(int) * NoLines);
}
//initializes all valid bits to 0 and the iruQueue entries to -1
for(i = 0; i < NoSets; i++)
for(j = 0; j < NoLines; j++)
{
cache[i].lines[j].valid = 0;
cache[i].iruQueue[j] = -1;
}
return cache;
}
So that is essentially the cache constructor. No problems there. There's a ton more code that I've written, but it all functions correctly after thorough testing.
A little more background: the iruQueue integer array is used to keep track of the least recently accessed line of a set. Ex: I have four lines, the array is initialized as an int * that looks like (-1, -1, -1, -1). Line 0 is accessed. (0, -1, -1, -1). Line 1 is accessed. (0, 1, -1, -1). Line 2 is accessed (0, 1, 2, -1). Line 0 is accessed again. (1, 2, 0, -1)
Here's my problem: at some point I want to pass the integer array to a function that will modify it within the cache. I have two functions for this purpose, enqueue and dequeue. Here's the enqueue function.
void enqueue(int ** iruQueue, int noLines, int lineNo)
{
int cached = 0;
int i;
for(i = 0; i < noLines; i++) {
if(*iruQueue[i] == -1 && cached == 0) {
*iruQueue[i] = lineNo;
cached = 1;
}
}
}
In the above function, I pass a pointer to the specific iruQueue array I want to modify as well as the number of lines in a set and the number of the line just used. It searches through the iruQueue, finds the first index with a value of -1 (indicating that the index is unused) and replaces it with the line number. I pass a specific iruQueue to this function like this.
cache(&(cache[setIndex].iruQueue), noLines, lineNo);
So here's where I really have a problem. I noticed that that it would work on the first call of enqueue, but wouldn't work properly on subsequent enqueues/dequeues.
Printing the specific queue like this prior to enqueues/dequeues (with NoSets being the number of setTypes in the cache array and NoLines being the number of lines in the set array)
int i, j;
for(i = 0; i < NoSets; i++) {
for(j = 0; i < NoLines; j++)
printf("%d, ", cache[i].iruQueue[j])
}
yields the following: "-1, -1, -1, -1, " when there are four lines and 1 set. After one enqueue with a lineNo of 0, it yields "0, -1, -1, -1, ". Proper functioning ends there.
I was curious, so within my enqueue function I added some code to print the iruQueue array before and after modification.
void enqueue(int ** iruQueue, int noLines, int lineNo)
{
int cached = 0;
int i;
//checks the iruQueue array prior to modification
printf("Before: \n");
for(i = 0; i < noLines; i++) {
printf("%d : %d\n", i, iruQueue[i]);
}
for(i = 0; i < noLines; i++) {
if(*iruQueue[i] == -1 && cached == 0) {
*iruQueue[i] = lineNo;
cached = 1;
}
}
//checks the iruQueue array after modification
printf("After: \n");
for(i = 0; i < noLines; i++) {
printf("%d: %d\n", i, iruQueue[i]);
}
}
Here's what it prints when we start with the unmodified iruQueue array (meaning all values should be -1), the number of lines being 4, and the line number being 0.
Before:
0 : -1
1 : 0
2 : -1
3 : 0
After:
0 : 0
1 : 0
2 : -1
3 : 0
It appears as though the iruQueue being modified has changed in that there are zeroes between each proper value. If I changed the print function to print through noLines * 2, the pattern would continue as such. That's my problem. When the iruQueue isn't passed to the enqueue/dequeue functions and I print its contents the same exact way, it will print correctly with no extra indices containing zeroes. Why would passing it as such change it like that, and is there anything I can do to fix it?
TL;DR
I pass an integer array (int * iruQueue) to a function by passing the address of the int array to the function ( &(cashe[setIndex].iruQueue) ). Outside the function it operates as it should, but when passed to the function it creates extra indices with 0 values inbetween each of the correct indices. How do I correct this problem?
If any more code/clarification is needed I will happily provide it. Also, if I'm doing this whole thing wrong (writing up waaaaayyyyy too much or something) just let me know- while I read a lot of things on this website to help my issues, I don't really ever post here, so I just wanted to be as thorough as possible.
Thanks!

Answer 1

Actually, your double pointer isn't needed here and complicates matters. You dereference it when accessing, but don't when printing (which is wrong; I wonder why it doesn't crash or produce more "random" output…). Simply reduce it to a single pointer:
void enqueue(int * iruQueue, int noLines, int lineNo)
{
int cached = 0;
int i;
for(i = 0; i < noLines; i++) {
if(iruQueue[i] == -1 && cached == 0) {
iruQueue[i] = lineNo;
cached = 1;
}
}
}
void foo()
{
enqueue(cache[setIndex].iruQueue, noLines, lineNo);
}