优化此 function 以提高速度

Question

I am trying to speed up this C function called "list_find",

int list_find(list_t *list, int value) {
    for (int i = 0; i < list->size; i++) {
        if (list_get(list, i) == value) {
            return i;
        }
    }
    return -1;
}

list_find searches for the index at which a particular value is stored. This implementation calls "get" to retrieve the value at index 0, then calls get to retrieve the value at index 1, and continues in this way until it either finds the value or hits the end of the list.

Arguments: list: Pointer to a linked list struct value: The value to search for

Returns: Index where the value is stored, or -1 if value is not found

for reference here is "list_get", which is used to retrieve the value stored at a particular index within a linked list, where the index is an index of a node with a value to retrieve:

int list_get(list_t *list, int index) {
    if (list == NULL) {
        return -1;
    }
    if (index >= list->size || index < 0) {
        return -1;
    }
    node_t *current = list->head;
    for (int i = 0; i < index; i++) {
        current = current->next;
    }
    return current->value;
}

Here are the structs for list_t and node_t:

typedef struct node {
    int value;
    struct node *next;
} node_t;


typedef struct list {
    int size;
    node_t *head;
} list_t;

I am looking to greatly improve the speed of list_find without changing any other functions or declarations. Essentially I am looking to only edit "list_find". Any tips would be helpful!!

UPDATE:

int list_find(list_t *list, int value) {
    if (list == NULL)
    {
        return -1;
    }
    node_t *current = list->head;
    int size = list->size;
    for (int i = 0; i < size; i++) {
        if (i >= size || i < 0)
        {
            return -1;
        }
        if (value == current->value)
        {
            return value;
        }
        current = current->next;
    }
    return -1;
}

I have eliminated the use of list_get and iterated the list inside the function, but it doesn't seem to be faster, otherwise the way that I wrote the way it's timed in main is off. How does this look?

Answer 1

The biggest problem is linked lists - the CPU has to fetch one element (with all the cache misses, etc) before it can try to fetch the next element; so all "out-of-order execution" parallelism is destroyed and the CPU spends almost all it's time waiting for one thing to happen at a time.

The biggest optimization is to not use a raw linked list.

For one example, if you used a linked list of structures where each structure contains a "next structure", a fixed size array and some meta-data to indicate which element/s of the array are used (eg first and last index); then with an array of 1234 elements iteration could be up to 1234 times faster than a raw linked list; partly because the next element in the list is likely to be in the same cache line as the previous element, and mostly because the CPU won't be spending almost all of its time stalled waiting for cache misses. Eg like:

    struct list_block {
        struct list_block * next;
        int used_elements;
        int array[1000];
    }

    int list_find(struct list_block * block, int value) {
        int k = 0;

        while(block != NULL) {
             for(int i = 0; i < block->used_elements; i++) {
                 if(block->array[i] == value) {
                     return k+i;
                 }
             }
             k += block->used_elements;
             block = block->next;
        }
        return -1;
    }