rw_lock_test.c

/*
 *  Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License").
 *  You may not use this file except in compliance with the License.
 *  A copy of the License is located at
 *
 *  http://aws.amazon.com/apache2.0
 *
 *  or in the "license" file accompanying this file. This file is distributed
 *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 *  express or implied. See the License for the specific language governing
 *  permissions and limitations under the License.
 */

#include <aws/common/rw_lock.h>
#include <aws/common/thread.h>
#include <aws/testing/aws_test_harness.h>

static int test_rw_lock_acquire_release(struct aws_allocator *allocator, void *ctx) {
    struct aws_rw_lock rw_lock;
    aws_rw_lock_init(&rw_lock);

    ASSERT_SUCCESS(aws_rw_lock_wlock(&rw_lock), "rw_lock acquire should have returned success.");
    ASSERT_SUCCESS(aws_rw_lock_wunlock(&rw_lock), "rw_lock release should have returned success.");

    ASSERT_SUCCESS(aws_rw_lock_rlock(&rw_lock), "rw_lock acquire should have returned success.");
    ASSERT_SUCCESS(aws_rw_lock_runlock(&rw_lock), "rw_lock release should have returned success.");

    aws_rw_lock_clean_up(&rw_lock);

    return 0;
}
AWS_TEST_CASE(rw_lock_aquire_release_test, test_rw_lock_acquire_release)

struct thread_rw_lock_data {
    struct aws_rw_lock rw_lock;
    volatile int counter;
    int max_counts;
    volatile int thread_fn_increments;
};

static void rw_lock_thread_fn(void *rw_lock_data) {
    struct thread_rw_lock_data *p_rw_lock = (struct thread_rw_lock_data *)rw_lock_data;
    int finished = 0;
    while (!finished) {

        aws_rw_lock_rlock(&p_rw_lock->rw_lock);

        if (p_rw_lock->counter != p_rw_lock->max_counts) {
            int counter = p_rw_lock->counter + 1;

            aws_rw_lock_runlock(&p_rw_lock->rw_lock);
            aws_rw_lock_wlock(&p_rw_lock->rw_lock);

            p_rw_lock->counter = counter;
            p_rw_lock->thread_fn_increments += 1;

            aws_rw_lock_wunlock(&p_rw_lock->rw_lock);
            aws_rw_lock_rlock(&p_rw_lock->rw_lock);

            finished = p_rw_lock->counter == p_rw_lock->max_counts;
        }
        else {
            finished = 1;
        }

        aws_rw_lock_runlock(&p_rw_lock->rw_lock);
    }
}

static int test_rw_lock_is_actually_rw_lock(struct aws_allocator *allocator, void *ctx) {

    struct thread_rw_lock_data rw_lock_data = {
        .counter = 0,
        .max_counts = 1000000,
        .thread_fn_increments = 0,
    };

    aws_rw_lock_init(&rw_lock_data.rw_lock);

    struct aws_thread thread;
    aws_thread_init(&thread, allocator);
    ASSERT_SUCCESS(aws_thread_launch(&thread, rw_lock_thread_fn, &rw_lock_data, 0), "thread creation failed with error %d", aws_last_error());
    int finished = 0;
    while (!finished) {

        aws_rw_lock_rlock(&rw_lock_data.rw_lock);

        finished = rw_lock_data.counter == rw_lock_data.max_counts;

        aws_rw_lock_runlock(&rw_lock_data.rw_lock);
    }

    ASSERT_SUCCESS(aws_thread_join(&thread), "Thread join failed with error code %d.", aws_last_error());
    ASSERT_INT_EQUALS(rw_lock_data.thread_fn_increments, rw_lock_data.max_counts, "Thread 2 should have written all data");
    ASSERT_INT_EQUALS(rw_lock_data.max_counts, rw_lock_data.counter, "Both threads should have written exactly the max counts.");

    aws_thread_clean_up(&thread);
    aws_rw_lock_clean_up(&rw_lock_data.rw_lock);

    return 0;
}
AWS_TEST_CASE(rw_lock_is_actually_rw_lock_test, test_rw_lock_is_actually_rw_lock)

static int g_iterations = 0;
static void thread_reader_fn(void *ud) {

    struct aws_rw_lock *lock = ud;

    int finished = 0;
    while (!finished) {

        aws_rw_lock_rlock(lock);

        finished = g_iterations == 10000;

        aws_rw_lock_runlock(lock);
    }
}

static int test_rw_lock_many_readers(struct aws_allocator *allocator, void *ctx) {

    struct aws_rw_lock lock;
    aws_rw_lock_init(&lock);

    struct aws_thread threads[8];
    AWS_ZERO_ARRAY(threads);

    for (size_t i = 0; i < sizeof(threads) / sizeof(threads[0]); ++i) {

        aws_thread_init(&threads[i], allocator);
        ASSERT_SUCCESS(aws_thread_launch(&threads[i], thread_reader_fn, &lock, 0), "thread creation failed with error %d", aws_last_error());
    }

    int finished = 0;
    while (!finished) {

        aws_rw_lock_wlock(&lock);

        finished = ++g_iterations == 10000;

        aws_rw_lock_wunlock(&lock);
    }

    for (size_t i = 0; i < sizeof(threads) / sizeof(threads[0]); ++i) {

        ASSERT_SUCCESS(aws_thread_join(&threads[i]), "Thread join failed with error code %d.", aws_last_error());
        aws_thread_clean_up(&threads[i]);
    }

    aws_rw_lock_clean_up(&lock);

    return 0;
}
AWS_TEST_CASE(rw_lock_many_readers_test, test_rw_lock_many_readers)