diff --git a/src/block_alloc.h b/src/block_alloc.h
index 8aa01452efd483e7f19c78a91289db0f7f61d178..ca4bba18c027d711994076a73db555c7a7518ea1 100644
--- a/src/block_alloc.h
+++ b/src/block_alloc.h
@@ -15,43 +15,15 @@
#undef PTR_HASH_ALLOC_FILL_PAGES
#undef PTR_HASH_ALLOC_FIXED_FILL_PAGES
-/* Define this to keep freed blocks around in a backlog, which can
- * help locating leftover pointers to other blocks. It can also hide
- * bugs since the blocks remain intact a while after they are freed.
- * Valgrind will immediately detect attempts to use blocks on the
- * backlog list, though. Only available with dmalloc debug. */
-/* #define DMALLOC_BLOCK_BACKLOG */
-
#define INIT_BLOCK(X)
#define EXIT_BLOCK(X)
#define BLOCK_ALLOC_HSIZE_SHIFT 2
-
-#if defined (DMALLOC_BLOCK_BACKLOG) && defined (DEBUG_MALLOC)
-#define DO_IF_BLOCK_BACKLOG(X) X
-#define DO_IF_NOT_BLOCK_BACKLOG(X)
-#define BLOCK_ALLOC_USED real_used
-#else
-#define DO_IF_BLOCK_BACKLOG(X)
-#define DO_IF_NOT_BLOCK_BACKLOG(X) X
-#define BLOCK_ALLOC_USED used
-#endif
-
#ifndef PIKE_HASH_T
#define PIKE_HASH_T size_t
#endif /* !PIKE_HASH_T */
-#ifdef PIKE_RUN_UNLOCKED
-#include "threads.h"
-
-/* Block Alloc UnLocked */
-#define BA_UL(X) PIKE_CONCAT(X,_unlocked)
-#define BA_STATIC static
-#define BA_INLINE INLINE
-#else
-#define BA_UL(X) X
#define BA_STATIC
#define BA_INLINE
-#endif
#define PTR_HASH_ALLOC_FILL_PAGES(DATA, PAGES) \
@@ -123,7 +95,7 @@ struct DATA **PIKE_CONCAT(DATA,_hash_table)=0; \
size_t PIKE_CONCAT(DATA,_hash_table_size)=0; \
static size_t PIKE_CONCAT(num_,DATA)=0; \
\
-static INLINE struct DATA * \
+static struct DATA * \
PIKE_CONCAT3(really_low_find_,DATA,_unlocked)(void *ptr, \
PIKE_HASH_T hval) \
{ \
@@ -147,14 +119,11 @@ struct DATA *PIKE_CONCAT(find_,DATA)(void *ptr) \
{ \
struct DATA *p; \
PIKE_HASH_T hval = ptr_hashfun(ptr); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
if(!PIKE_CONCAT(DATA,_hash_table)) { \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return 0; \
} \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
p=PIKE_CONCAT3(really_low_find_,DATA,_unlocked)(ptr, hval); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return p; \
} \
\
@@ -179,14 +148,11 @@ static struct DATA *PIKE_CONCAT(just_find_,DATA)(void *ptr) \
{ \
struct DATA *p; \
PIKE_HASH_T hval = ptr_hashfun(ptr); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
if(!PIKE_CONCAT(DATA,_hash_table)) { \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return 0; \
} \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
p=PIKE_CONCAT3(just_find_,DATA,_unlocked)(ptr, hval); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return p; \
} \
\
@@ -196,10 +162,8 @@ struct DATA *PIKE_CONCAT(make_,DATA)(void *ptr) \
{ \
struct DATA *p; \
PIKE_HASH_T hval = ptr_hashfun(ptr); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
p=PIKE_CONCAT3(make_,DATA,_unlocked)(ptr,hval); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return p; \
} \
\
@@ -207,27 +171,22 @@ struct DATA *PIKE_CONCAT(get_,DATA)(void *ptr) \
{ \
struct DATA *p; \
PIKE_HASH_T hval = ptr_hashfun(ptr); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
if(!(p=PIKE_CONCAT3(really_low_find_,DATA,_unlocked)(ptr, hval))) \
p=PIKE_CONCAT3(make_,DATA,_unlocked)(ptr, hval); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return p; \
} \
\
int PIKE_CONCAT3(check_,DATA,_semaphore)(void *ptr) \
{ \
PIKE_HASH_T hval = ptr_hashfun(ptr); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
if(PIKE_CONCAT3(really_low_find_,DATA,_unlocked)(ptr, hval)) \
{ \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return 0; \
} \
\
PIKE_CONCAT3(make_,DATA,_unlocked)(ptr, hval); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return 1; \
} \
\
@@ -235,7 +194,6 @@ void PIKE_CONCAT(move_,DATA)(struct DATA *block, void *new_ptr) \
{ \
struct DATA **pp, *p; \
PIKE_HASH_T hval = ptr_hashfun(block->PTR_HASH_ALLOC_DATA); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
pp=PIKE_CONCAT(DATA,_hash_table) + hval; \
while((p = *pp)) \
@@ -253,17 +211,14 @@ void PIKE_CONCAT(move_,DATA)(struct DATA *block, void *new_ptr) \
((PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1); \
block->BLOCK_ALLOC_NEXT = PIKE_CONCAT(DATA,_hash_table)[hval]; \
PIKE_CONCAT(DATA,_hash_table)[hval] = block; \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
} \
\
int PIKE_CONCAT(remove_,DATA)(void *ptr) \
{ \
struct DATA **pp, *p; \
PIKE_HASH_T hval = ptr_hashfun(ptr); \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
if(!PIKE_CONCAT(DATA,_hash_table)) \
{ \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return 0; \
} \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
@@ -274,19 +229,16 @@ int PIKE_CONCAT(remove_,DATA)(void *ptr) \
{ \
*pp = p->BLOCK_ALLOC_NEXT; \
PIKE_CONCAT(num_,DATA)--; \
- BA_UL(PIKE_CONCAT(really_free_,DATA))(p); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
+ PIKE_CONCAT(really_free_,DATA)(p); \
return 1; \
} \
pp = &p->BLOCK_ALLOC_NEXT; \
} \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
return 0; \
} \
\
-void PIKE_CONCAT3(low_init_,DATA,_hash)(size_t size) \
+static void PIKE_CONCAT3(low_init_,DATA,_hash)(size_t size) \
{ \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
PIKE_CONCAT(DATA,_hash_table_size)= \
ptr_hash_find_hashsize(size); \
\
@@ -299,30 +251,27 @@ void PIKE_CONCAT3(low_init_,DATA,_hash)(size_t size) \
} \
MEMSET(PIKE_CONCAT(DATA,_hash_table),0, \
sizeof(struct DATA *)*PIKE_CONCAT(DATA,_hash_table_size)); \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
} \
\
\
-void PIKE_CONCAT3(init_,DATA,_hash)(void) \
+static void PIKE_CONCAT3(init_,DATA,_hash)(void) \
{ \
PIKE_CONCAT3(low_init_,DATA,_hash)(BSIZE); \
} \
\
-void PIKE_CONCAT3(exit_,DATA,_hash)(void) \
+static void PIKE_CONCAT3(exit_,DATA,_hash)(void) \
{ \
- DO_IF_RUN_UNLOCKED(mt_lock(&PIKE_CONCAT(DATA,_mutex))); \
ba_free_all(& PIKE_CONCAT(DATA,_allocator)); \
free(PIKE_CONCAT(DATA,_hash_table)); \
PIKE_CONCAT(DATA,_hash_table)=0; \
PIKE_CONCAT(num_,DATA)=0; \
- DO_IF_RUN_UNLOCKED(mt_unlock(&PIKE_CONCAT(DATA,_mutex))); \
}
#define PTR_HASH_ALLOC_FIXED(DATA,BSIZE) \
-struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, PIKE_HASH_T hval);\
+static struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, PIKE_HASH_T hval);\
LOW_PTR_HASH_ALLOC(DATA,BSIZE) \
\
-struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, PIKE_HASH_T hval) \
+static struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, PIKE_HASH_T hval) \
{ \
struct DATA *p; \
\
@@ -330,7 +279,7 @@ struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, PIKE_HASH_T hval) \
Pike_fatal("Hash table error!\n"); ) \
PIKE_CONCAT(num_,DATA)++; \
\
- p=BA_UL(PIKE_CONCAT(alloc_,DATA))(); \
+ p=PIKE_CONCAT(alloc_,DATA)(); \
p->PTR_HASH_ALLOC_DATA=ptr; \
p->BLOCK_ALLOC_NEXT=PIKE_CONCAT(DATA,_hash_table)[hval]; \
PIKE_CONCAT(DATA,_hash_table)[hval]=p; \
@@ -339,7 +288,7 @@ struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, PIKE_HASH_T hval) \
#define PTR_HASH_ALLOC(DATA,BSIZE) \
-struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, \
+static struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, \
PIKE_HASH_T hval); \
LOW_PTR_HASH_ALLOC(DATA,BSIZE) \
\
@@ -379,7 +328,7 @@ static void PIKE_CONCAT(DATA,_rehash)(void) \
} \
} \
\
-struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, \
+static struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, \
PIKE_HASH_T hval) \
{ \
struct DATA *p; \
@@ -396,7 +345,7 @@ struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked)(void *ptr, \
hval &= (PIKE_HASH_T)PIKE_CONCAT(DATA,_hash_table_size) - 1; \
} \
\
- p=BA_UL(PIKE_CONCAT(alloc_,DATA))(); \
+ p=PIKE_CONCAT(alloc_,DATA)(); \
p->PTR_HASH_ALLOC_DATA=ptr; \
p->BLOCK_ALLOC_NEXT=PIKE_CONCAT(DATA,_hash_table)[hval]; \
PIKE_CONCAT(DATA,_hash_table)[hval]=p; \
diff --git a/src/block_alloc_h.h b/src/block_alloc_h.h
index 24fa542279bcbb28d6dd1a0c1bc21c49932491dc..37cd38c82dfea8d7bd5bc4ee9e37d706181219f5 100644
--- a/src/block_alloc_h.h
+++ b/src/block_alloc_h.h
@@ -30,16 +30,11 @@ BLOCK_ALLOC(DATA,BSIZE); \
extern struct DATA **PIKE_CONCAT(DATA,_hash_table); \
extern size_t PIKE_CONCAT(DATA,_hash_table_size); \
struct DATA *PIKE_CONCAT(find_,DATA)(void *ptr); \
-struct DATA *PIKE_CONCAT3(make_,DATA,_unlocked) \
- (void *ptr, PIKE_HASH_T hval); \
struct DATA *PIKE_CONCAT(make_,DATA)(void *ptr); \
struct DATA *PIKE_CONCAT(get_,DATA)(void *ptr); \
int PIKE_CONCAT3(check_,DATA,_semaphore)(void *ptr); \
void PIKE_CONCAT(move_,DATA)(struct DATA *block, void *new_ptr); \
-int PIKE_CONCAT(remove_,DATA)(void *ptr); \
-void PIKE_CONCAT3(low_init_,DATA,_hash)(size_t); \
-void PIKE_CONCAT3(init_,DATA,_hash)(void); \
-void PIKE_CONCAT3(exit_,DATA,_hash)(void);
+int PIKE_CONCAT(remove_,DATA)(void *ptr);
#define PTR_HASH_ALLOC_FIXED(DATA,BSIZE) \
PTR_HASH_ALLOC(DATA,BSIZE)
diff --git a/src/global.h b/src/global.h
index d882f2f8dc301f84d11026965bb1cbc8cb0e7bdf..7522a868f42b21229a3006ddeb3324122562d9de 100644
--- a/src/global.h
+++ b/src/global.h
@@ -695,14 +695,7 @@ char *crypt(const char *, const char *);
/* Compatibility... */
#define USE_PIKE_TYPE 2
-#ifdef PIKE_RUN_UNLOCKED
-#define DO_IF_RUN_UNLOCKED(X) X
-#else
-#define DO_IF_RUN_UNLOCKED(X)
-#endif
-
/* Used in more than one place, better put it here */
-
#if defined(PROFILING)
#define DO_IF_PROFILING(X) X
#else
diff --git a/src/module.c b/src/module.c
index 1f6f02293e5593621bc16ab05b4cc136ff51e1bc..25bfdf5340b97ed1be7cc843c5cc909a742eea9f 100644
--- a/src/module.c
+++ b/src/module.c
@@ -350,7 +350,6 @@ static void exit_builtin_modules(void)
cleanup_callbacks();
free_all_callable_blocks();
- exit_destroy_called_mark_hash();
cleanup_pike_type_table();
cleanup_shared_string_table();
diff --git a/src/multiset.h b/src/multiset.h
index 591764fcae3789a5d23c552c4b28528d9eaa456c..10a73018e1ced66f892d3a491fc1429dcf2bc62a 100644
--- a/src/multiset.h
+++ b/src/multiset.h
@@ -52,9 +52,6 @@ union msnode
struct multiset_data
{
INT32 refs, noval_refs;
-#ifdef PIKE_RUN_UNLOCKED
-#error multiset_data has not been adapted for running unlocked.
-#endif
union msnode *root, *free_list;
struct svalue cmp_less;
INT32 size, allocsize;
diff --git a/src/object.c b/src/object.c
index 96a45095683c48e08c0636d2109db9be7080ee29..7afbc3aaed56af15f4a3317fe282558898b593df 100644
--- a/src/object.c
+++ b/src/object.c
@@ -3279,6 +3279,8 @@ void exit_object(void)
free_program(magic_types_program);
magic_types_program=0;
}
+
+ exit_destroy_called_mark_hash();
}
#ifdef PIKE_DEBUG
diff --git a/src/pike_cpulib.h b/src/pike_cpulib.h
index 318d88539d9fd00a8670adbf16bdd5beae7749c3..a7575f421ec7cc893cd2f46e86fcaaa94a043d54 100644
--- a/src/pike_cpulib.h
+++ b/src/pike_cpulib.h
@@ -56,427 +56,6 @@ PMOD_EXPORT void x86_get_cpuid(int oper, INT32 *cpuid_ptr);
#endif
#endif
-/* FIXME: Should we have an #ifdef PIKE_RUN_UNLOCKED here? -Hubbe
- * Good side: No problems compiling unless --run-unlocked is used
- * Bad side: Can't use these things for other purposes..
- */
-/* Since the memlock stuff doesn't work yet, I disable the code for now.
- * /grubba
- */
-#ifdef PIKE_RUN_UNLOCKED
-
-#define pike_atomic_fool_gcc(x) (*(volatile struct { int a[100]; } *)x)
-
-
-/* These will work on any cpu, but should only be used as a
- * last resort. We must also define PIKE_NEED_MEMLOCK if we
- * use these. /Hubbe
- */
-#define BEGIN_MEMORY_LOCK(ADDR) do { \
- PIKE_MUTEX_T *pike_mem_mutex=pike_memory_locks+ \
- ((unsigned long)(ADDR))%PIKE_MEM_HASH; \
- mt_lock(pike_mem_mutex)
-
-#define END_MEMORY_LOCK() \
- mt_unlock(pike_mem_mutex); \
- }while(0)
-
-#define pike_memlock(ADDR) do{ \
- PIKE_MUTEX_T *pike_mem_mutex=pike_memory_locks+ \
- ((unsigned long)(ADDR))%PIKE_MEM_HASH; \
- mt_lock(pike_mem_mutex) \
-}while(0)
-
-#define pike_unmemlock(ADDR) do{ \
- PIKE_MUTEX_T *pike_mem_mutex=pike_memory_locks+ \
- ((unsigned long)(ADDR))%PIKE_MEM_HASH; \
- mt_unlock(pike_mem_mutex) \
-}while(0)
-
-#define PIKE_NEED_MEMLOCK
-
-/* Autoconf this? */
-#if defined(__i386__) && defined(__GNUC__)
-
-/*
- * ia32 general purpose registers
- * "a" = %eax, "b" = %edx, "c" = %ecx, "d" = %edx
- * "S" = %esi, "D" = %edi, "B" = %ebp
- */
-
-
-#define PIKE_HAS_INC32
-static INLINE void pike_atomic_inc32(volatile INT32 *v)
-{
- __asm__ __volatile__("lock ; incl %0"
- :"=m" (pike_atomic_fool_gcc(v))
- :"m" (pike_atomic_fool_gcc(v))
- :"cc");
-}
-
-
-#define PIKE_HAS_DEC_AND_TEST32
-static INLINE int pike_atomic_dec_and_test32(INT32 *v)
-{
- unsigned char c;
-
- __asm__ __volatile__("lock ; decl %0; setne %1"
- :"=m" (pike_atomic_fool_gcc(v)), "=qm" (c)
- :"m" (pike_atomic_fool_gcc(v))
- :"cc");
- return c;
-}
-
-#define PIKE_HAS_COMPARE_AND_SWAP32
-static INLINE int
-pike_atomic_compare_and_swap32 (INT32 *p, INT32 oldval, INT32 newval)
-{
- char ret;
- INT32 readval;
-
- __asm__ __volatile__ ("lock; cmpxchgl %3, %1; sete %0"
- : "=q" (ret), "=m" (*p), "=a" (readval)
- : "r" (newval), "m" (*p), "a" (oldval)
- : "cc", "memory");
- return ret;
-}
-
-
-/* NOT USED */
-#define PIKE_HAS_COMPARE_AND_SWAP64
-static INLINE int
-pike_atomic_compare_and_swap64 (INT64 *p, INT64 oldval, INT64 newval)
-{
- char ret;
-#define HIGH(X) ((INT32 *)&(X))[1]
-#define LOW(X) ((INT32 *)&(X))[0]
-
-#if 1
- INT32 t1, t2, t3;
-/*fprintf(stderr,"cas64(%p(%llx),%llx,%llx) << %d\n",p,*p,oldval,newval,ret);*/
-#if 0
- __asm__ __volatile__ (
- "xchgl %%ebx, %%edi ;"
- "lock; cmpxchg8b (%%esi); sete %%al;"
- "movl %%edi, %%ebx; "
- "movb %%al, %0 "
- :"=q" (ret),
- "=a" (t1),"=d" (t2),"=D" (t3)
- :"S" (p),
- "1" (LOW(oldval)), "2" (HIGH(oldval)),
- "3" (LOW(newval)), "c" (HIGH(newval))
- :"cc", "memory");
-#else
- __asm__ __volatile__ (
- "xchgl %%ebx, %%edi ;"
- "lock; cmpxchg8b (%%esi); sete %%al;"
- "movl %%edi, %%ebx; "
- "movb %%al, %0 "
- :"=q" (ret),
- "=a" (t1),"=d" (t2),"=D" (t3)
- :"S" (p),
- "a" (LOW(oldval)), "d" (HIGH(oldval)),
- "D" (LOW(newval)), "c" (HIGH(newval))
- :"cc", "memory");
-#endif
-/*fprintf(stderr,"cas64(%p(%llx),%llx,%llx) => %d\n",p,*p,oldval,newval,ret);*/
-#else
- INT32 readval;
- /* this doesn't work because GCC use %ebp for PIC code */
- __asm__ __volatile__ ("lock; cmpxchg8b (%1); sete %0"
- :"=q" (ret), "=m" (*p)
- :"r" (newval), "m" (*p),
- "a" (LOW(oldval)),"d" (HIGH(oldval)),
- "b" (LOW(newval)),"c" (HIGH(newval))
- : "cc", "memory");
-#endif
- return ret;
-}
-
-#endif /* __i386__ && __GNUC__ */
-
-#if defined(__ia64__) && defined(__GNUC__)
-
-#define PIKE_HAS_COMPARE_AND_SWAP32
-
-static INLINE int
-pike_atomic_compare_and_swap32 (INT32 *p, INT32 oldval, INT32 newval)
-{
- INT32 ret;
-
- __asm__ __volatile__ ("mov ar.ccv = %1;\n"
- "\t;;\n"
- "\tcmpxchg4.rel.nta %0 = [%2], %3, ar.ccv"
- : "=r" (ret)
- : "r" (oldval), "r" (p), "r" (newval)
- : "memory", "ar.ccv");
- return ret == oldval;
-}
-
-#endif /* __ia64__ && __GNUC__ */
-
-#if defined(_M_IA64)
-
-#define PIKE_HAS_COMPARE_AND_SWAP32
-
-static INLINE int
-pike_atomic_compare_and_swap32 (INT32 *p, INT32 oldval, INT32 newval)
-{
- return _InterlockedCompareExchange(p, newval, oldval) == oldval;
-}
-
-#endif /* _M_IA64 */
-
-#if defined(__sparc_v9__) && defined(__GNUC__)
-
-#define PIKE_HAS_COMPARE_AND_SWAP32
-
-static INLINE int
-pike_atomic_compare_and_swap32 (INT32 *p, INT32 oldval, INT32 newval)
-{
- __asm__ __volatile__ ("membar #LoadStore\n"
- "cas [%2], %3, %0"
- : "=r" (newval)
- : "0" (newval), "r" (p), "r" (oldval)
- : "memory");
- return newval == oldval;
-}
-
-#endif /* __sparc_v9__ && __GNUC__ */
-
-#if defined(__m68k__) && defined(__GNUC__)
-
-
-#define PIKE_HAS_COMPARE_AND_SWAP32
-
-static INLINE int
-pike_atomic_compare_and_swap32 (INT32 *p, INT32 oldval, INT32 newval)
-{
- INT32 cmpval = oldval;
-
- /* if (oldval == *p) {
- * *p = newval;
- * } else {
- * oldval = *p;
- * }
- */
- __asm__ __volatile__ ("casl %0, %3, %1;"
- : "=d" (oldval), "=m", (*p)
- : "0" (oldval), "d" (newval), "0" (p)
- : "memory");
- return oldval == cmpval;
-}
-
-#endif /* __m68k__ && __GNUC__ */
-
-
-
-/*
- * These functions are used if we don't have
- * compare-and-swap instructions available
- */
-#ifndef PIKE_HAS_COMPARE_AND_SWAP32
-
-#define PIKE_HAS_COMPARE_AND_SWAP32
-#undef PIKE_NEED_MEMLOCK
-#define PIKE_NEED_MEMLOCK
-
-#include "threads.h"
-
-static INLINE int
-pike_atomic_compare_and_swap32 (INT32 *p, INT32 oldval, INT32 newval)
-{
- int ret;
- BEGIN_MEMORY_LOCK(p);
- if(ret == (*p == oldval)) *p=newval;
- END_MEMORY_LOCK();
- return ret;
-}
-
-
-#ifndef PIKE_HAS_INC32
-#define PIKE_HAS_INC32
-static INLINE void pike_atomic_inc32(INT32 *ref)
-{
- BEGIN_MEMORY_LOCK(p);
- ref++;
- END_MEMORY_LOCK();
-}
-#endif /* PIKE_HAS_INC32 */
-
-#ifndef PIKE_HAS_DEC_AND_TEST32
-#define PIKE_HAS_DEC_AND_TEST32
-static INLINE int pike_atomic_dec_and_test32(INT32 *ref)
-{
- INT32 ret;
- BEGIN_MEMORY_LOCK(p);
- ret=--ref;
- END_MEMORY_LOCK();
- return ret;
-}
-#endif /* PIKE_HAS_DEC_AND_TEST32 */
-
-
-
-#ifndef PIKE_HAS_SWAP32
-#define PIKE_HAS_SWAP32
-static INLINE INT32 pike_atomic_swap32(INT32 *addr, INT32 newval)
-{
- INT32 ret;
- BEGIN_MEMORY_LOCK(p);
- ret=*addr;
- *addr=newval;
- END_MEMORY_LOCK();
- return ret;
-}
-#endif
-
-#endif /* PIKE_HAS_COMPARE_AND_SWAP32 */
-
-#if !defined(PIKE_HAS_COMPARE_AND_SWAP64) && defined(INT64)
-
-#define PIKE_HAS_COMPARE_AND_SWAP64
-#undef PIKE_NEED_MEMLOCK
-#define PIKE_NEED_MEMLOCK
-
-#include "threads.h"
-
-static INLINE int
-pike_atomic_compare_and_swap64 (INT64 *p, INT64 oldval, INT64 newval)
-{
- int ret;
- BEGIN_MEMORY_LOCK(p);
- if(ret == (*p == oldval)) *p=newval;
- END_MEMORY_LOCK();
- return ret;
-}
-
-
-#ifndef PIKE_HAS_SWAP64
-#define PIKE_HAS_SWAP64
-static INLINE INT64 pike_atomic_swap64(INT64 *addr, INT64 newval)
-{
- INT64 ret;
- BEGIN_MEMORY_LOCK(p);
- ret=*addr;
- *addr=newval;
- END_MEMORY_LOCK();
- return ret;
-}
-#endif
-
-
-#ifndef PIKE_HAS_SET64
-#define PIKE_HAS_SET64
-static INLINE void pike_atomic_set64(INT64 *addr, INT64 newval)
-{
- BEGIN_MEMORY_LOCK(p);
- *addr=newval;
- END_MEMORY_LOCK();
-}
-#endif
-
-#ifndef PIKE_HAS_GET64
-#define PIKE_HAS_GET64
-static INLINE INT64 pike_atomic_get64(INT64 *addr)
-{
- INT64 ret;
- BEGIN_MEMORY_LOCK(p);
- ret=*addr;
- END_MEMORY_LOCK();
- return ret;
-}
-#endif
-
-
-#endif /* PIKE_HAS_COMPARE_AND_SWAP64 */
-
-
-
-/* These functions are used if we have
- * compare-and-swap, but not the rest of
- * the atomic functions
- */
-
-#if defined(PIKE_HAS_COMPARE_AND_SWAP32) && !defined(PIKE_HAS_INC32)
-#define PIKE_HAS_INC32
-static INLINE void pike_atomic_inc32(INT32 *ref)
-{
- INT32 oldrefs;
- do
- oldrefs=*ref;
- while(! pike_atomic_compare_and_swap32(ref, oldrefs, oldrefs+1));
-}
-#endif
-
-
-#if defined(PIKE_HAS_COMPARE_AND_SWAP32) && !defined(PIKE_HAS_DEC_AND_TEST32)
-#define PIKE_HAS_DEC_AND_TEST32
-static INLINE int pike_atomic_dec_and_test32(INT32 *ref)
-{
- INT32 oldrefs;
- do
- oldrefs=*ref;
- while(! pike_atomic_compare_and_swap32(ref, oldrefs, oldrefs-1));
- return oldrefs-1;
-}
-#endif
-
-
-#if defined(PIKE_HAS_COMPARE_AND_SWAP32) && !defined(PIKE_HAS_SWAP32)
-#define PIKE_HAS_SWAP32
-static INLINE INT32 pike_atomic_swap32(INT32 *addr, INT32 newval)
-{
- INT32 ret;
- do
- {
- ret=*addr;
- }while(!pike_atomic_compare_and_swap32(addr, ret, newval));
- return ret;
-}
-#endif
-
-
-#if defined(PIKE_HAS_COMPARE_AND_SWAP64) && !defined(PIKE_HAS_SWAP64)
-#define PIKE_HAS_SWAP64
-static INLINE INT64 pike_atomic_swap64(INT64 *addr, INT64 newval)
-{
- INT64 ret;
- do
- {
- ret=*addr;
- }while(!pike_atomic_compare_and_swap64(addr, ret, newval));
- return ret;
-}
-#endif
-
-
-
-#if defined(PIKE_HAS_SWAP64) && !defined(PIKE_HAS_SET64)
-#define PIKE_HAS_SET64
-static INLINE void pike_atomic_set64(INT64 *addr, INT64 newval)
-{
- pike_atomic_swap64(addr, newval);
-}
-#endif
-
-#if defined(PIKE_HAS_COMPARE_AND_SWAP64) && !defined(PIKE_HAS_GET64)
-#define PIKE_HAS_GET64
-static INLINE INT64 pike_atomic_get64(INT64 *addr)
-{
- INT64 ret;
- do
- {
- ret=*addr;
- }while(!pike_atomic_compare_and_swap64(addr, ret, ret));
- return ret;
-}
-#endif
-
-/* End emulating functions */
-
-#endif /* PIKE_RUN_UNLOCKED */
-
#ifdef PIKE_NEED_MEMLOCK
extern void init_pike_cpulib(void);
#else
diff --git a/src/stralloc.c b/src/stralloc.c
index 54c483957a3024ccd127370c8818b17d17a02507..e9aca391aee6bc384c5229196e52c696c4651b89 100644
--- a/src/stralloc.c
+++ b/src/stralloc.c
@@ -40,37 +40,6 @@ static unsigned INT32 htable_mask;
#define ULONG_MAX UINT_MAX
#endif
-#if PIKE_RUN_UNLOCKED
-/* Make this bigger when we get lightweight threads */
-#define BUCKET_LOCKS 2048
-static PIKE_MUTEX_T *bucket_locks;
-
-#define BUCKETLOCK(HVAL) \
- (bucket_locks + (HMODULO(hval__) & (BUCKET_LOCKS-1)))
-
-#define LOCK_BUCKET(HVAL) do { \
- size_t hval__=(HVAL); \
- PIKE_MUTEX_T *bucket_lock; \
- while(1) \
- { \
- bucket_lock=BUCKETLOCK(hval__); \
- mt_lock(bucket_lock); \
- if(bucket_lock == BUCKETLOCK(hval__)) \
- break; \
- mt_unlock(bucket_lock); \
- } \
-}while(0)
-
-#define UNLOCK_BUCKET(HVAL) do { \
- size_t hval__=(HVAL); \
- mt_unlock(BUCKETLOCK(hval__)); \
-}while(0)
-
-#else
-#define LOCK_BUCKET(HVAL)
-#define UNLOCK_BUCKET(HVAL)
-#endif /* PIKE_RUN_UNLOCKED */
-
#define BEGIN_HASH_SIZE 1024
static unsigned int hash_prefix_len=64;
@@ -414,7 +383,6 @@ static void locate_problem(int (*isproblem)(const struct pike_string *))
for(e=0;e<htable_size;e++)
{
- LOCK_BUCKET(e);
for(s=base_table[e];s;s=s->next)
{
if(isproblem(s))
@@ -426,7 +394,6 @@ static void locate_problem(int (*isproblem)(const struct pike_string *))
DM(add_marks_to_memhdr(no,s));
}
}
- UNLOCK_BUCKET(e);
}
DM(fprintf(stderr,"Plausible problem location(s):\n"));
@@ -471,7 +438,6 @@ static struct pike_string *internal_findstring(const char *s,
unsigned int prefix_depth=0;
size_t h;
- LOCK_BUCKET(hval);
h=HMODULO(hval);
for(curr = base_table[h]; curr; curr = curr->next)
{
@@ -494,7 +460,6 @@ static struct pike_string *internal_findstring(const char *s,
/* *prev = curr->next; */
/* curr->next = *base; */
/* *base = curr; */
- UNLOCK_BUCKET(hval);
return curr; /* pointer to string */
}
depth++;
@@ -517,7 +482,6 @@ static struct pike_string *internal_findstring(const char *s,
#endif /* 0 */
need_more_hash_prefix_depth = prefix_depth;
}
- UNLOCK_BUCKET(hval);
return 0; /* not found */
}
@@ -633,22 +597,6 @@ static void stralloc_rehash(void)
old=htable_size;
old_base=base_table;
-#ifdef PIKE_RUN_UNLOCKED
- mt_lock(bucket_locks);
- if(old != htable_size)
- {
- /* Someone got here before us */
- mt_lock(bucket_locks);
- return;
- }
-
- /* Now that we have bucket zero, the hash table
- * cannot change, go ahead and lock ALL buckets.
- * NOTE: bucket zero is already locked
- */
- for(h=1;h<BUCKET_LOCKS;h++) mt_lock(bucket_locks+h);
-#endif
-
SET_HSIZE( ++hashprimes_entry );
base_table=xcalloc(sizeof(struct pike_string *), htable_size);
@@ -660,10 +608,6 @@ static void stralloc_rehash(void)
if(old_base)
free(old_base);
-
-#ifdef PIKE_RUN_UNLOCKED
- for(h=0;h<BUCKET_LOCKS;h++) mt_unlock(bucket_locks + h);
-#endif
}
/* Allocation of strings */
@@ -741,14 +685,12 @@ static void link_pike_string(struct pike_string *s, size_t hval)
Pike_fatal ("Got undefined contents in pike string %p.\n", s);
#endif
- LOCK_BUCKET(hval);
h=HMODULO(hval);
s->next = base_table[h];
base_table[h] = s;
s->hval=hval;
s->flags &= ~(STRING_NOT_HASHED|STRING_NOT_SHARED);
num_strings++;
- UNLOCK_BUCKET(hval);
if(num_strings > htable_size) {
stralloc_rehash();
@@ -784,25 +726,9 @@ static void link_pike_string(struct pike_string *s, size_t hval)
need_new_hashkey_depth = 0;
}
-#ifdef PIKE_RUN_UNLOCKED
- mt_lock(bucket_locks);
- if(need_more_hash_prefix_depth <= 4)
- {
- /* Someone got here before us */
- mt_lock(bucket_locks);
- return;
- }
- for(h=1;h<BUCKET_LOCKS;h++) mt_lock(bucket_locks+h);
-#endif
-
- if (need_more_hash_prefix_depth > 4)
- {
+ if (need_more_hash_prefix_depth > 4)
hash_prefix_len=hash_prefix_len*2;
-#if 0
- fprintf(stderr, "Doubling hash_prefix_len to %d and rehashing\n",
- hash_prefix_len);
-#endif /* 0 */
- }
+
/* NOTE: No need to update to the correct values, since that will
* be done on demand.
*/
@@ -825,9 +751,6 @@ static void link_pike_string(struct pike_string *s, size_t hval)
base_table[h2]=tmp2;
}
}
-#ifdef PIKE_RUN_UNLOCKED
- for(h=0;h<BUCKET_LOCKS;h++) mt_unlock(bucket_locks + h);
-#endif
}
}
@@ -1136,7 +1059,6 @@ PMOD_EXPORT struct pike_string *debug_make_shared_string2(const p_wchar2 *str)
static void unlink_pike_string(struct pike_string *s)
{
size_t h;
- LOCK_BUCKET(s->hval);
h= HMODULO(s->hval);
propagate_shared_string(s,h);
#ifdef PIKE_DEBUG
@@ -1149,7 +1071,6 @@ static void unlink_pike_string(struct pike_string *s)
s->next=(struct pike_string *)(ptrdiff_t)-1;
#endif
num_strings--;
- UNLOCK_BUCKET(s->hval);
s->flags |= STRING_NOT_SHARED;
}
@@ -1228,7 +1149,6 @@ struct pike_string *add_string_status(int verbose)
struct pike_string *p;
for(e=0;e<htable_size;e++)
{
- LOCK_BUCKET(e);
for(p=base_table[e];p;p=p->next)
{
int is_short = (p->len <= SHORT_STRING_THRESHOLD);
@@ -1245,7 +1165,6 @@ struct pike_string *add_string_status(int verbose)
alloced_bytes[key] +=
p->refs*DO_ALIGN((p->len+3) << p->size_shift,sizeof(void *));
}
- UNLOCK_BUCKET(e);
}
string_builder_sprintf(&s,
"\nShared string hash table:\n"
@@ -1387,7 +1306,6 @@ PMOD_EXPORT void verify_shared_strings_tables(void)
for(e=0;e<htable_size;e++)
{
h=0;
- LOCK_BUCKET(e);
for(s=base_table[e];s;s=s->next)
{
num++;
@@ -1433,7 +1351,6 @@ PMOD_EXPORT void verify_shared_strings_tables(void)
h=0;
}
}
- UNLOCK_BUCKET(e);
}
if(num != num_strings)
Pike_fatal("Num strings is wrong %d!=%d\n",num,num_strings);
@@ -1446,16 +1363,13 @@ int safe_debug_findstring(struct pike_string *foo)
for(e=0;e<htable_size;e++)
{
struct pike_string *p;
- LOCK_BUCKET(e);
for(p=base_table[e];p;p=p->next)
{
if(p==foo)
{
- UNLOCK_BUCKET(e);
return 1;
}
}
- UNLOCK_BUCKET(e);
}
return 0;
}
@@ -1476,7 +1390,6 @@ struct pike_string *debug_findstring(const struct pike_string *foo)
(long)foo->len,
foo->str);
- LOCK_BUCKET(foo->hval);
fprintf(stderr,"------ %p %ld\n",
base_table[HMODULO(foo->hval)],
foo->hval);
@@ -1488,11 +1401,9 @@ struct pike_string *debug_findstring(const struct pike_string *foo)
fprintf(stderr,"%p->",tmp2);
}
fprintf(stderr,"0\n");
- UNLOCK_BUCKET(foo->hval);
for(e=0;e<htable_size;e++)
{
- LOCK_BUCKET(e);
for(tmp2=base_table[e];tmp2;tmp2=tmp2->next)
{
if(tmp2 == tmp)
@@ -1500,7 +1411,6 @@ struct pike_string *debug_findstring(const struct pike_string *foo)
(long)e,
(long)HMODULO(foo->hval));
}
- UNLOCK_BUCKET(e);
}
}
#endif /* 0 */
@@ -1551,14 +1461,12 @@ void dump_stralloc_strings(void)
struct pike_string *p;
for(e=0;e<htable_size;e++)
{
- LOCK_BUCKET(e);
for(p=base_table[e];p;p=p->next) {
debug_dump_pike_string(p, 70);
#ifdef DEBUG_MALLOC
debug_malloc_dump_references (p, 2, 1, 0);
#endif
}
- UNLOCK_BUCKET(e);
}
}
@@ -2261,13 +2169,6 @@ void init_shared_string_table(void)
SET_HSIZE(hashprimes_entry);
base_table=xcalloc(sizeof(struct pike_string *), htable_size);
-#ifdef PIKE_RUN_UNLOCKED
- {
- int h;
- bucket_locks=xalloc(sizeof(PIKE_MUTEX_T)*BUCKET_LOCKS);
- for(h=0;h<BUCKET_LOCKS;h++) mt_init(bucket_locks + h);
- }
-#endif
empty_pike_string = make_shared_string("");
empty_pike_string->flags |= STRING_CONTENT_CHECKED | STRING_IS_LOWERCASE | STRING_IS_UPPERCASE;
empty_pike_string->min = empty_pike_string->max = 0;
@@ -2314,18 +2215,12 @@ void cleanup_shared_string_table(void)
for(e=0;e<htable_size;e++)
{
- LOCK_BUCKET(e);
for(s=base_table[e];s;s=next)
{
next=s->next;
-#ifdef REALLY_FREE
- free_unlinked_pike_string(s);
-#else
s->next=0;
-#endif
}
base_table[e]=0;
- UNLOCK_BUCKET(e);
}
free(base_table);
base_table=0;
@@ -2362,13 +2257,11 @@ void count_memory_in_strings(size_t *num, size_t *size)
for(e=0;e<htable_size;e++)
{
struct pike_string *p;
- LOCK_BUCKET(e);
for(p=base_table[e];p;p=p->next)
{
num_++;
size_ += memory_in_string (p);
}
- UNLOCK_BUCKET(e);
}
#ifdef PIKE_DEBUG
if(num_strings != num_)
@@ -2427,10 +2320,8 @@ struct pike_string *next_pike_string (struct pike_string *s)
size_t h = s->hval;
do {
h++;
- LOCK_BUCKET(h);
h = HMODULO(h);
next = base_table[h];
- UNLOCK_BUCKET(h);
} while (!next);
}
return next;
@@ -3785,10 +3676,6 @@ PMOD_EXPORT double STRTOD_PCHARP(PCHARP nptr, PCHARP *endptr)
underflow:
/* Return an underflow error. */
-#if 0
- if (endptr != NULL)
- *endptr = nptr;
-#endif
errno = ERANGE;
return 0.0;
diff --git a/src/svalue.h b/src/svalue.h
index 6a183a4c315fdffea6654692e55dd92f9af810a8..ba129c341bf7289103edb6ae9627f2c54ad00224 100644
--- a/src/svalue.h
+++ b/src/svalue.h
@@ -417,29 +417,8 @@ do{ \
}while(0)
-#ifdef PIKE_RUN_UNLOCKED
-#define add_ref(X) pike_atomic_inc32(&(X)->refs)
-#define sub_ref(X) pike_atomic_dec_and_test32(&(X)->refs)
-
-#if 0
-#define IF_LOCAL_MUTEX(X) X
-#define USE_LOCAL_MUTEX
-#define pike_lock_data(X) mt_lock(&(X)->mutex)
-#define pike_unlock_data(X) mt_unlock(&(X)->mutex)
-#else
-#define IF_LOCAL_MUTEX(X)
-#define pike_lock_data(X) pike_lockmem((X))
-#define pike_unlock_data(X) pike_unlockmem((X))
-#endif
-
-#else
-#define IF_LOCAL_MUTEX(X)
-#define add_ref(X) (void)((X)->refs++)
+#define add_ref(X) ((void)((X)->refs++))
#define sub_ref(X) (--(X)->refs > 0)
-#define pike_lock_data(X) (void)(X)
-#define pike_unlock_data(X) (void)(X)
-#endif
-
#ifdef PIKE_DEBUG
PMOD_EXPORT extern void describe(void *); /* defined in gc.c */
@@ -508,15 +487,8 @@ if(REFCOUNTED_TYPE(T) && (S)->refs && (S)->refs[0] <= 0) {\
#ifdef DEBUG_MALLOC
static INLINE struct svalue *dmalloc_check_svalue(struct svalue *s, char *l)
{
-#if 0
- /* What's this supposed to accomplish? Dmalloc tracks memory blocks,
- * not single svalues that point to them. /mast */
- debug_malloc_update_location(s,l);
-#endif
-#if 1
if(s && REFCOUNTED_TYPE(TYPEOF(*s)))
debug_malloc_update_location(s->u.refs,l);
-#endif
return s;
}
@@ -528,32 +500,20 @@ static INLINE struct svalue *dmalloc_check_svalues(struct svalue *s, size_t num,
static INLINE union anything *dmalloc_check_union(union anything *u,int type, char * l)
{
-#if 0
- debug_malloc_update_location(u,l);
-#endif
-#if 1
if(u && REFCOUNTED_TYPE(type))
debug_malloc_update_location(u->refs,l);
-#endif
return u;
}
#undef add_ref
-#undef sub_ref
-
-#ifdef PIKE_RUN_UNLOCKED
-#define add_ref(X) pike_atomic_inc32((INT32 *)debug_malloc_update_location( &((X)->refs), DMALLOC_NAMED_LOCATION(" add_ref")))
-#define sub_ref(X) pike_atomic_dec_and_test32((INT32 *)debug_malloc_update_location( &((X)->refs), DMALLOC_NAMED_LOCATION(" sub_ref")))
-#else
#define add_ref(X) (((INT32 *)debug_malloc_update_location( &((X)->refs), DMALLOC_NAMED_LOCATION(" add_ref")))[0]++)
+#undef sub_ref
#define sub_ref(X) (--((INT32 *)debug_malloc_update_location( &((X)->refs), DMALLOC_NAMED_LOCATION(" sub_ref")))[0] > 0)
-#endif
#else /* !DEBUG_MALLOC */
#define dmalloc_check_svalue(S,L) (S)
#define dmalloc_check_svalues(S,L,N) (S)
#define dmalloc_check_union(U,T,L) (U)
-
#endif /* !DEBUG_MALLOC */
/* To be used for type checking in macros. */
@@ -620,30 +580,18 @@ static INLINE struct callable *pass_callable (struct callable *c) {return c;}
); \
} while (0)
-/* This define
- * should check that the svalue address (X) is on the local stack,
- * the processor stack or in a locked memory object
- *
- * Or, it could just try to make sure it's not in an unlocked memory
- * object...
- */
-#define assert_svalue_locked(X)
-
-
-#define swap_svalues_unlocked(X,Y) do { \
+#define swap_svalues(X,Y) do { \
struct svalue *_a=(X); \
struct svalue *_b=(Y); \
struct svalue _tmp; \
- assert_svalue_locked(_a); assert_svalue_locked(_b); \
dmalloc_touch_svalue(_a); \
dmalloc_touch_svalue(_b); \
_tmp=*_a; *_a=*_b; *_b=_tmp; \
}while(0)
/* Handles PIKE_T_FREE. */
-#define free_svalue_unlocked(X) do { \
+#define free_svalue(X) do { \
struct svalue *_s=(X); \
- assert_svalue_locked(_s); \
DO_IF_DEBUG ( \
if (TYPEOF(*_s) != PIKE_T_FREE) { \
check_svalue_type(_s); \
@@ -664,10 +612,9 @@ static INLINE struct callable *pass_callable (struct callable *c) {return c;}
} \
}while(0)
-#define free_short_svalue_unlocked(X,T) do { \
+#define free_short_svalue(X,T) do { \
union anything *_s=(X); TYPE_T _t=(T); \
check_type(_t); check_refs2(_s,_t); \
- assert_svalue_locked(_s); \
if(REFCOUNTED_TYPE(_t) && _s->refs) { \
DO_IF_DEBUG ( \
DO_IF_PIKE_CLEANUP ( \
@@ -680,7 +627,7 @@ static INLINE struct callable *pass_callable (struct callable *c) {return c;}
}while(0)
/* Handles PIKE_T_FREE. */
-#define add_ref_svalue_unlocked(X) do { \
+#define add_ref_svalue(X) do { \
struct svalue *_tmp=(X); \
DO_IF_DEBUG ( \
if (TYPEOF(*_tmp) != PIKE_T_FREE) { \
@@ -692,7 +639,7 @@ static INLINE struct callable *pass_callable (struct callable *c) {return c;}
}while(0)
/* Handles PIKE_T_FREE. */
-#define assign_svalue_no_free_unlocked(X,Y) do { \
+#define assign_svalue_no_free(X,Y) do { \
struct svalue *_to=(X); \
const struct svalue *_from=(Y); \
DO_IF_DEBUG ( \
@@ -708,7 +655,7 @@ static INLINE struct callable *pass_callable (struct callable *c) {return c;}
}while(0)
/* Handles PIKE_T_FREE. */
-#define assign_svalue_unlocked(X,Y) do { \
+#define assign_svalue(X,Y) do { \
struct svalue *_to2=(X); \
const struct svalue *_from2=(Y); \
if (_to2 != _from2) { \
@@ -908,124 +855,6 @@ static INLINE TYPE_FIELD dmalloc_gc_cycle_check_svalues (struct svalue *s, size_
#endif /* !NO_PIKE_SHORTHAND */
-#if 0 /* PIKE_RUN_UNLOCKED */
-
-#include "pike_error.h"
-
-/*#define swap_svalues swap_svalues*/
-/*#define free_svalue free_svalue_unlocked*/
-/*#define free_short_svalue free_short_svalue_unlocked */
-/*#define add_ref_svalue add_ref_svalue_unlocked*/
-
-/*
- * These don't work right now - Hubbe
- */
-#define assign_svalue_no_free assign_svalue_no_free_unlocked
-#define assign_svalue assign_svalue_unlocked
-
-/* FIXME:
- * These routines assumes that pointers are 32 bit
- * and svalues 64 bit!!!!! - Hubbe
- */
-
-#ifndef swap_svalues
-#define swap_svalues swap_svalues_unlocked
-#endif
-
-#ifndef free_svalue
-static INLINE void free_svalue(struct svalue *s)
-{
- INT64 tmp;
- struct svalue zero;
- SET_SVAL(zero, PIKE_T_INT, NUMBER_NUMBER, integer, 0);
- tmp=pike_atomic_swap64((INT64 *)s, *(INT64 *)&zero);
- free_svalue_unlocked((struct svalue *)&tmp);
-}
-#endif
-
-#ifndef free_short_svalue
-static INLINE void free_short_svalue(union anything *s, int t)
-{
- if(REFCOUNTED_TYPE(t))
- {
- INT32 tmp;
- tmp=pike_atomic_swap32((INT32 *)s, 0);
- free_short_svalue_unlocked((union anything *)&tmp, t);
- }
-}
-#endif
-
-#ifndef add_ref_svalue
-static INLINE void add_ref_svalue(struct svalue *s)
-{
- INT64 sv;
- sv=pike_atomic_get64((INT64 *)s);
- add_ref_svalue_unlocked((struct svalue *)&sv);
-}
-#endif
-
-#ifndef assign_svalue_no_free
-void assign_svalue_no_free(struct svalue *to, const struct svalue *from)
-{
- INT64 tmp, sv;
- sv=pike_atomic_get64((INT64 *)from);
-#ifdef PIKE_DEBUG
- if(sv != *(INT64*)from)
- {
- fprintf(stderr,"pike_atomic_get64() is broken %llx != %llx (%08x%08x)!\n",
- sv,
- *(INT64*)from,
- ((INT32*)from)[1], ((INT32*)from)[0]);
- abort();
- }
-#endif
- add_ref_svalue_unlocked((struct svalue *)&sv);
- pike_atomic_set64((INT64 *)to, sv);
-#ifdef PIKE_DEBUG
- if(*(INT64*)to != *(INT64*)from)
- {
- fprintf(stderr,"pike_atomic_set64() is broken!\n");
- abort();
- }
-#endif
-}
-#endif
-
-#ifndef assign_svalue
-static INLINE void assign_svalue(struct svalue *to, const struct svalue *from)
-{
- INT64 tmp, sv;
- if(to != from)
- {
- sv=pike_atomic_get64((INT64 *)from);
- add_ref_svalue_unlocked((struct svalue *)&sv);
- tmp=pike_atomic_swap64((INT64 *)to, sv);
- free_svalue_unlocked((struct svalue *)&tmp);
- }
-}
-#endif
-
-#else /* FOO_PIKE_RUN_UNLOCKED */
-#define swap_svalues swap_svalues_unlocked
-#define free_svalue free_svalue_unlocked
-#define free_short_svalue free_short_svalue_unlocked
-#define add_ref_svalue add_ref_svalue_unlocked
-#define assign_svalue_no_free assign_svalue_no_free_unlocked
-#define assign_svalue assign_svalue_unlocked
-#endif /* FOO_PIKE_RUN_UNLOCKED */
-
-#ifdef PIKE_RUN_UNLOCKED
-#include "pike_threadlib.h"
-#endif
-
-/*
- * Note to self:
- * It might be better to use a static array of mutexes instead
- * and just lock mutex ptr % array_size instead.
- * That way I wouldn't need a mutex in each memory object,
- * but it would cost a couple of cycles in every lock/unlock
- * operation instead.
- */
#ifdef ATOMIC_SVALUE
/* Atomic svalues: Store the type in the reference types,
* instead of on the stack. This allows for changing an
@@ -1035,7 +864,6 @@ static INLINE void assign_svalue(struct svalue *to, const struct svalue *from)
INT32 refs; \
INT32 ref_type \
DO_IF_SECURITY(; struct object *prot) \
- IF_LOCAL_MUTEX(; PIKE_MUTEX_T mutex)
#ifdef PIKE_SECURITY
#ifdef USE_LOCAL_MUTEX
@@ -1057,13 +885,11 @@ static INLINE void assign_svalue(struct svalue *to, const struct svalue *from)
v_->refs=0; \
add_ref(v_); /* For DMALLOC... */ \
DO_IF_SECURITY( INITIALIZE_PROT(v_) ); \
- IF_LOCAL_MUTEX(mt_init_recursive(&(v_->mutex))); \
}while(0)
#else /* !ATOMIC_SVALUE */
#define PIKE_MEMORY_OBJECT_MEMBERS \
INT32 refs \
DO_IF_SECURITY(; struct object *prot) \
- IF_LOCAL_MUTEX(; PIKE_MUTEX_T mutex)
#ifdef PIKE_SECURITY
#ifdef USE_LOCAL_MUTEX
@@ -1084,14 +910,12 @@ static INLINE void assign_svalue(struct svalue *to, const struct svalue *from)
v_->refs=0; \
add_ref(v_); /* For DMALLOC... */ \
DO_IF_SECURITY( INITIALIZE_PROT(v_) ); \
- IF_LOCAL_MUTEX(mt_init_recursive(&(v_->mutex))); \
}while(0)
#endif /* ATOMIC_SVALUE */
#define EXIT_PIKE_MEMOBJ(X) do { \
struct ref_dummy *v_=(struct ref_dummy *)(X); \
DO_IF_SECURITY( FREE_PROT(v_) ); \
- IF_LOCAL_MUTEX(mt_destroy(&(v_->mutex))); \
}while(0)