Merge branch 'master' into blender2.8
authorSergey Sharybin <sergey.vfx@gmail.com>
Tue, 20 Mar 2018 15:55:16 +0000 (16:55 +0100)
committerSergey Sharybin <sergey.vfx@gmail.com>
Tue, 20 Mar 2018 15:55:16 +0000 (16:55 +0100)
12 files changed:
doc/guides/blender-guardedalloc.txt
intern/guardedalloc/MEM_guardedalloc.h
intern/guardedalloc/intern/mallocn.c
intern/guardedalloc/intern/mallocn_guarded_impl.c
intern/guardedalloc/intern/mallocn_intern.h
intern/guardedalloc/intern/mallocn_lockfree_impl.c
intern/guardedalloc/test/simpletest/memtest.c
source/blender/blenkernel/intern/cachefile.c
source/blender/blenlib/BLI_assert.h
source/blender/blenlib/intern/math_base_inline.c
source/blender/depsgraph/intern/depsgraph_types.h
source/blender/depsgraph/util/deg_util_function.h

index 3db647a4e7775291d53335e635e03cb3429c17c4..2e49f25bd9273f2f022d438cd88567145925caa1 100644 (file)
@@ -51,7 +51,7 @@ void MEM_printmemlist(void);
 - if err_stream is set by MEM_set_error_stream() this function dumps a list of all
 currently allocated memory blocks with length and name to the stream
 
-int MEM_check_memory_integrity(void);
+bool MEM_consistency_check(void);
 
 - this function tests if the internal structures of the memory manager are intact
 - returns 0 on success and !=0 on error
index a57921223e23d4a75afc7e96f5c379faf7ab4697..65650209711cde215a8176ade19d09cc6f3d9b1d 100644 (file)
@@ -165,8 +165,8 @@ extern "C" {
        /**
         * Are the start/end block markers still correct ?
         *
-        * @retval 0 for correct memory, 1 for corrupted memory. */
-       extern bool (*MEM_check_memory_integrity)(void);
+        * @retval true for correct memory, false for corrupted memory. */
+       extern bool (*MEM_consistency_check)(void);
 
        /** Set thread locking functions for safe memory allocation from multiple
         * threads, pass NULL pointers to disable thread locking again. */
index b973037358b06cbd1d45424bed5549e1aded09aa..a95cc9163c421b4c3cc0ce98e4aec82b6504df80 100644 (file)
@@ -53,7 +53,7 @@ void (*MEM_printmemlist)(void) = MEM_lockfree_printmemlist;
 void (*MEM_callbackmemlist)(void (*func)(void *)) = MEM_lockfree_callbackmemlist;
 void (*MEM_printmemlist_stats)(void) = MEM_lockfree_printmemlist_stats;
 void (*MEM_set_error_callback)(void (*func)(const char *)) = MEM_lockfree_set_error_callback;
-bool (*MEM_check_memory_integrity)(void) = MEM_lockfree_check_memory_integrity;
+bool (*MEM_consistency_check)(void) = MEM_lockfree_consistency_check;
 void (*MEM_set_lock_callback)(void (*lock)(void), void (*unlock)(void)) = MEM_lockfree_set_lock_callback;
 void (*MEM_set_memory_debug)(void) = MEM_lockfree_set_memory_debug;
 size_t (*MEM_get_memory_in_use)(void) = MEM_lockfree_get_memory_in_use;
@@ -119,7 +119,7 @@ void MEM_use_guarded_allocator(void)
        MEM_callbackmemlist = MEM_guarded_callbackmemlist;
        MEM_printmemlist_stats = MEM_guarded_printmemlist_stats;
        MEM_set_error_callback = MEM_guarded_set_error_callback;
-       MEM_check_memory_integrity = MEM_guarded_check_memory_integrity;
+       MEM_consistency_check = MEM_guarded_consistency_check;
        MEM_set_lock_callback = MEM_guarded_set_lock_callback;
        MEM_set_memory_debug = MEM_guarded_set_memory_debug;
        MEM_get_memory_in_use = MEM_guarded_get_memory_in_use;
index d012cce53345c44df5fc38d09118f1d307a70aeb..d09f1b83ad4e36fef12cf11f0b33c7ba01a2c13c 100644 (file)
@@ -282,7 +282,7 @@ static void mem_unlock_thread(void)
                thread_unlock_callback();
 }
 
-bool MEM_guarded_check_memory_integrity(void)
+bool MEM_guarded_consistency_check(void)
 {
        const char *err_val = NULL;
        MemHead *listend;
@@ -292,7 +292,7 @@ bool MEM_guarded_check_memory_integrity(void)
        
        err_val = check_memlist(listend);
 
-       return (err_val != NULL);
+       return (err_val == NULL);
 }
 
 
index 4b2282ae9ad4ded7c914155e874132da07ec76c3..754a79f08b5ed393d792c1c80fd76dd11fc5f709 100644 (file)
@@ -137,7 +137,7 @@ void MEM_lockfree_printmemlist(void);
 void MEM_lockfree_callbackmemlist(void (*func)(void *));
 void MEM_lockfree_printmemlist_stats(void);
 void MEM_lockfree_set_error_callback(void (*func)(const char *));
-bool MEM_lockfree_check_memory_integrity(void);
+bool MEM_lockfree_consistency_check(void);
 void MEM_lockfree_set_lock_callback(void (*lock)(void), void (*unlock)(void));
 void MEM_lockfree_set_memory_debug(void);
 size_t MEM_lockfree_get_memory_in_use(void);
@@ -166,7 +166,7 @@ void MEM_guarded_printmemlist(void);
 void MEM_guarded_callbackmemlist(void (*func)(void *));
 void MEM_guarded_printmemlist_stats(void);
 void MEM_guarded_set_error_callback(void (*func)(const char *));
-bool MEM_guarded_check_memory_integrity(void);
+bool MEM_guarded_consistency_check(void);
 void MEM_guarded_set_lock_callback(void (*lock)(void), void (*unlock)(void));
 void MEM_guarded_set_memory_debug(void);
 size_t MEM_guarded_get_memory_in_use(void);
index 2899a37a1b28ae4b4e6310a79e853892e32752ef..4c6ba0cb256d0db41017002572372a7dfe376659 100644 (file)
@@ -469,7 +469,7 @@ void MEM_lockfree_set_error_callback(void (*func)(const char *))
        error_callback = func;
 }
 
-bool MEM_lockfree_check_memory_integrity(void)
+bool MEM_lockfree_consistency_check(void)
 {
        return true;
 }
index 79d55dd02cc321da6d28b5e48333d93eb8014a0a..d306337d0abd568ba1e3e09ba3082607b7391455 100644 (file)
@@ -90,7 +90,7 @@ int main(int argc, char *argv[])
        if (verbose > 1) MEM_printmemlist();
 
        /* memory is there: test it */
-       error_status = MEM_check_memory_integrity();
+       error_status = MEM_consistency_check();
 
        if (verbose) {
                if (error_status) {
@@ -125,7 +125,7 @@ int main(int argc, char *argv[])
        ip = (int*) p[6];
        *(ip+10005) = 0;
        
-       retval = MEM_check_memory_integrity();
+       retval = MEM_consistency_check();
 
        /* the test should have failed */
        error_status |= !retval;                
index f8215668034be3add7946591ef25392448465c71..aebec3dfeedd3b58ea8a76ad694f2fdda1d0b5dc 100644 (file)
@@ -181,7 +181,6 @@ void BKE_cachefile_update_frame(Main *bmain, Scene *scene, const float ctime, co
                        ABC_free_handle(cache_file->handle);
                        cache_file->handle = ABC_create_handle(filename, NULL);
 #endif
-                       break;
                }
        }
 }
index 9fb0954e77fee5daaf20465b05320b2b534cc76e..b66b95b21fe45a11f89939bfe681b43956e47e18 100644 (file)
@@ -46,33 +46,28 @@ extern "C" {
 
 #ifndef NDEBUG
 #  include "BLI_system.h"
-#  ifdef WITH_ASSERT_ABORT
-#    define _BLI_DUMMY_ABORT abort
+   /* _BLI_ASSERT_PRINT_POS */
+#  if defined(__GNUC__)
+#    define _BLI_ASSERT_PRINT_POS(a) \
+       fprintf(stderr, "BLI_assert failed: %s:%d, %s(), at \'%s\'\n", __FILE__, __LINE__, __func__, #a)
+#  elif defined(_MSC_VER)
+#    define _BLI_ASSERT_PRINT_POS(a) \
+       fprintf(stderr, "BLI_assert failed: %s:%d, %s(), at \'%s\'\n", __FILE__, __LINE__, __FUNCTION__, #a)
 #  else
-#    define _BLI_DUMMY_ABORT() (void)0
+#    define _BLI_ASSERT_PRINT_POS(a) \
+       fprintf(stderr, "BLI_assert failed: %s:%d, at \'%s\'\n", __FILE__, __LINE__, #a)
 #  endif
-#  if defined(__GNUC__) || defined(_MSC_VER) /* check __func__ is available */
-#    define BLI_assert(a)                                                     \
-       (void)((!(a)) ?  (                                                        \
-               (                                                                     \
-               BLI_system_backtrace(stderr),                                         \
-               fprintf(stderr,                                                       \
-                       "BLI_assert failed: %s:%d, %s(), at \'%s\'\n",                    \
-                       __FILE__, __LINE__, __func__, "" #a),                             \
-               _BLI_DUMMY_ABORT(),                                                   \
-               NULL)) : NULL)
+   /* _BLI_ASSERT_ABORT */
+#  ifdef WITH_ASSERT_ABORT
+#    define _BLI_ASSERT_ABORT abort
 #  else
-#    define BLI_assert(a)                                                     \
-       (void)((!(a)) ?  (                                                        \
-               (                                                                     \
-               fprintf(stderr,                                                       \
-                       "BLI_assert failed: %s:%d, at \'%s\'\n",                          \
-                       __FILE__, __LINE__, "" #a),                                       \
-               _BLI_DUMMY_ABORT(),                                                   \
-               NULL)) : NULL)
+#    define _BLI_ASSERT_ABORT() (void)0
 #  endif
+   /* BLI_assert */
+#  define BLI_assert(a) \
+       (void)((!(a)) ? ((BLI_system_backtrace(stderr), _BLI_ASSERT_PRINT_POS(a), _BLI_ASSERT_ABORT(), NULL)) : NULL)
 #else
-#  define BLI_assert(a) (void)0
+#  define BLI_assert(a) ((void)0)
 #endif
 
 /* C++ can't use _Static_assert, expects static_assert() but c++0x only,
@@ -85,19 +80,19 @@ extern "C" {
 /* Code adapted from http://www.pixelbeat.org/programming/gcc/static_assert.html */
 /* Note we need the two concats below because arguments to ## are not expanded, so we need to
  * expand __LINE__ with one indirection before doing the actual concatenation. */
-#  define ASSERT_CONCAT_(a, b) a##b
-#  define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b)
+#  define _BLI_ASSERT_CONCAT_(a, b) a##b
+#  define _BLI_ASSERT_CONCAT(a, b) _BLI_ASSERT_CONCAT_(a, b)
    /* These can't be used after statements in c89. */
 #  if defined(__COUNTER__)  /* MSVC */
 #    define BLI_STATIC_ASSERT(a, msg) \
-         ; enum { ASSERT_CONCAT(static_assert_, __COUNTER__) = 1 / (int)(!!(a)) };
+         ; enum { _BLI_ASSERT_CONCAT(static_assert_, __COUNTER__) = 1 / (int)(!!(a)) };
 #  else  /* older gcc, clang... */
     /* This can't be used twice on the same line so ensure if using in headers
      * that the headers are not included twice (by wrapping in #ifndef...#endif)
      * Note it doesn't cause an issue when used on same line of separate modules
      * compiled with gcc -combine -fwhole-program. */
 #    define BLI_STATIC_ASSERT(a, msg) \
-         ; enum { ASSERT_CONCAT(assert_line_, __LINE__) = 1 / (int)(!!(a)) };
+         ; enum { _BLI_ASSERT_CONCAT(assert_line_, __LINE__) = 1 / (int)(!!(a)) };
 #  endif
 #endif
 
index 1f517471407ef272d628b6bd8e48d22b1081bdc3..eed06c7841b3dc69173462990e044d0e9b2c455c 100644 (file)
@@ -368,10 +368,8 @@ MINLINE int compare_ff_relative(float a, float b, const float max_diff, const in
 {
        union {float f; int i;} ua, ub;
 
-#if 0  /* No BLI_assert in INLINE :/ */
        BLI_assert(sizeof(float) == sizeof(int));
        BLI_assert(max_ulps < (1 << 22));
-#endif
 
        if (fabsf(a - b) <= max_diff) {
                return 1;
index f8699186866f2c2a83a84ec38ee39086c98ae97c..b4a0dde1f350ee4322177631ed552edc80afa0c3 100644 (file)
@@ -43,6 +43,7 @@
  */
 #include <string>
 #include <vector>
+#include <algorithm>
 
 struct bAction;
 struct ChannelDriver;
index da31bb037f9b0269e90684daec60576adb07de5e..96f52147fe760bef2ae338dfacec99ba3b98afef 100644 (file)
@@ -30,7 +30,7 @@
 
 #pragma once
 
-#if (__cplusplus > 199711L)
+#if (__cplusplus > 199711L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
 
 #include <functional>