thodg/libgit2/tests/threads/atomic.c

• Show log

  Commit

• Hash : 74708a81
  Author :
  Date : 2020-12-20T12:45:01
  

  Homogenize semantics for atomic-related functions
  
  There were some subtle semantic differences between the various
  implementations of atomic functions. Now they behave the same, have
  tests and are better documented to avoid this from happening again in
  the future.
  
  Of note:
  
  * The semantics chosen for `git_atomic_compare_and_swap` match
    `InterlockedCompareExchangePointer`/`__sync_cal_compare_and_swap` now.
  * The semantics chosen for `git_atomic_add` match
    `InterlockedAdd`/`__atomic_add_fetch`.
  * `git_atomic_swap` and `git_atomic_load` still have a bit of semantic
    difference with the gcc builtins / msvc interlocked operations, since
    they require an l-value (not a pointer). If desired, this can be
    homogenized.
  

Download

• tests/threads/atomic.c

• #include "clar_libgit2.h"
  
  void test_threads_atomic__atomic32_set(void)
  {
  	git_atomic32 v = {0};
  	git_atomic32_set(&v, 1);
  	cl_assert_equal_i(v.val, 1);
  }
  
  void test_threads_atomic__atomic32_get(void)
  {
  	git_atomic32 v = {1};
  	cl_assert_equal_i(git_atomic32_get(&v), 1);
  }
  
  void test_threads_atomic__atomic32_inc(void)
  {
  	git_atomic32 v = {0};
  	cl_assert_equal_i(git_atomic32_inc(&v), 1);
  	cl_assert_equal_i(v.val, 1);
  }
  
  void test_threads_atomic__atomic32_add(void)
  {
  	git_atomic32 v = {0};
  	cl_assert_equal_i(git_atomic32_add(&v, 1), 1);
  	cl_assert_equal_i(v.val, 1);
  }
  
  void test_threads_atomic__atomic32_dec(void)
  {
  	git_atomic32 v = {1};
  	cl_assert_equal_i(git_atomic32_dec(&v), 0);
  	cl_assert_equal_i(v.val, 0);
  }
  
  void test_threads_atomic__atomic64_set(void)
  {
  #ifndef GIT_ARCH_64
  	cl_skip();
  #else
  	git_atomic64 v = {0};
  	git_atomic64_set(&v, 1);
  	cl_assert_equal_i(v.val, 1);
  #endif
  }
  
  void test_threads_atomic__atomic64_get(void)
  {
  #ifndef GIT_ARCH_64
  	cl_skip();
  #else
  	git_atomic64 v = {1};
  	cl_assert_equal_i(git_atomic64_get(&v), 1);
  #endif
  }
  
  void test_threads_atomic__atomic64_add(void)
  {
  #ifndef GIT_ARCH_64
  	cl_skip();
  #else
  	git_atomic64 v = {0};
  	cl_assert_equal_i(git_atomic64_add(&v, 1), 1);
  	cl_assert_equal_i(v.val, 1);
  #endif
  }
  
  void test_threads_atomic__cas_pointer(void)
  {
  	int *value = NULL;
  	int newvalue1 = 1, newvalue2 = 2;
  
  	/* value is updated */
  	cl_assert_equal_p(git_atomic_compare_and_swap(&value, NULL, &newvalue1), NULL);
  	cl_assert_equal_p(value, &newvalue1);
  
  	/* value is not updated */
  	cl_assert_equal_p(git_atomic_compare_and_swap(&value, NULL, &newvalue2), &newvalue1);
  	cl_assert_equal_p(value, &newvalue1);
  }
  
  void test_threads_atomic__cas_intptr(void)
  {
  	intptr_t value = 0;
  	intptr_t oldvalue;
  	intptr_t newvalue;
  
  	/* value is updated */
  	oldvalue = 0;
  	newvalue = 1;
  	cl_assert_equal_i((intptr_t)git_atomic_compare_and_swap(&value, (void *)oldvalue, (void *)newvalue), 0);
  	cl_assert_equal_i(value, 1);
  
  	/* value is not updated */
  	oldvalue = 0;
  	newvalue = 2;
  	cl_assert_equal_i((intptr_t)git_atomic_compare_and_swap(&value, (void *)oldvalue, (void *)newvalue), 1);
  	cl_assert_equal_i(value, 1);
  }
  
  void test_threads_atomic__swap(void)
  {
  	int *value = NULL;
  	int newvalue = 1;
  
  	cl_assert_equal_p(git_atomic_swap(value, &newvalue), NULL);
  	cl_assert_equal_p(value, &newvalue);
  
  	cl_assert_equal_p(git_atomic_swap(value, NULL), &newvalue);
  	cl_assert_equal_p(value, NULL);
  }
  
  void test_threads_atomic__load_ptr(void)
  {
  	int value = 1;
  	int *ptr = &value;
  	cl_assert_equal_p(git_atomic_load(ptr), &value);
  }
  
  void test_threads_atomic__load_intptr(void)
  {
  	intptr_t value = 1;
  	cl_assert_equal_i((intptr_t)git_atomic_load(value), 1);
  }
  

Download