#include "objc-private.h"

#include "objc-sync.h"

typedef struct SyncData {

struct SyncData* nextData;

DisguisedPtr<objc_object> object;

int32_t threadCount; // number of THREADS using this block

recursive_mutex_t mutex;

} SyncData;

typedef struct {

SyncData *data;

unsigned int lockCount; // number of times THIS THREAD locked this block

} SyncCacheItem;

typedef struct SyncCache {

unsigned int allocated;

unsigned int used;

SyncCacheItem list[0];

} SyncCache;

struct SyncList {

SyncData *data;

spinlock_t lock;

SyncList() : data(nil), lock(fork_unsafe_lock) { }

};

#define LOCK_FOR_OBJ(obj) sDataLists[obj].lock

#define LIST_FOR_OBJ(obj) sDataLists[obj].data

static StripedMap<SyncList> sDataLists;

enum usage { ACQUIRE, RELEASE, CHECK };

static SyncCache *fetch_cache(bool create)

{

_objc_pthread_data *data;

data = _objc_fetch_pthread_data(create);

if (!data) return NULL;

if (!data->syncCache) {

if (!create) {

return NULL;

} else {

int count = 4;

data->syncCache = (SyncCache *)

calloc(1, sizeof(SyncCache) + count*sizeof(SyncCacheItem));

data->syncCache->allocated = count;

}

}

// Make sure there's at least one open slot in the list.

if (data->syncCache->allocated == data->syncCache->used) {

data->syncCache->allocated *= 2;

data->syncCache = (SyncCache *)

realloc(data->syncCache, sizeof(SyncCache)

+ data->syncCache->allocated * sizeof(SyncCacheItem));

}

return data->syncCache;

}

void _destroySyncCache(struct SyncCache *cache)

{

if (cache) free(cache);

}

static SyncData* id2data(id object, enum usage why)

{

spinlock_t *lockp = &LOCK_FOR_OBJ(object);

SyncData **listp = &LIST_FOR_OBJ(object);

SyncData* result = NULL;

#if SUPPORT_DIRECT_THREAD_KEYS

// Check per-thread single-entry fast cache for matching object

bool fastCacheOccupied = NO;

SyncData *data = (SyncData *)tls_get_direct(SYNC_DATA_DIRECT_KEY);

if (data) {

fastCacheOccupied = YES;

if (data->object == object) {

// Found a match in fast cache.

uintptr_t lockCount;

result = data;

lockCount = (uintptr_t)tls_get_direct(SYNC_COUNT_DIRECT_KEY);

if (result->threadCount <= 0 || lockCount <= 0) {

_objc_fatal("id2data fastcache is buggy");

}

switch(why) {

case ACQUIRE: {

lockCount++;

tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);

break;

}

case RELEASE:

lockCount--;

tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);

if (lockCount == 0) {

// remove from fast cache

tls_set_direct(SYNC_DATA_DIRECT_KEY, NULL);

// atomic because may collide with concurrent ACQUIRE

OSAtomicDecrement32Barrier(&result->threadCount);

}

break;

case CHECK:

// do nothing

break;

}

return result;

}

}

#endif

// Check per-thread cache of already-owned locks for matching object

SyncCache *cache = fetch_cache(NO);

if (cache) {

unsigned int i;

for (i = 0; i < cache->used; i++) {

SyncCacheItem *item = &cache->list[i];

if (item->data->object != object) continue;

// Found a match.

result = item->data;

if (result->threadCount <= 0 || item->lockCount <= 0) {

_objc_fatal("id2data cache is buggy");

}

switch(why) {

case ACQUIRE:

item->lockCount++;

break;

case RELEASE:

item->lockCount--;

if (item->lockCount == 0) {

// remove from per-thread cache

cache->list[i] = cache->list[--cache->used];

// atomic because may collide with concurrent ACQUIRE

OSAtomicDecrement32Barrier(&result->threadCount);

}

break;

case CHECK:

// do nothing

break;

}

return result;

}

}

// Thread cache didn't find anything.

// Walk in-use list looking for matching object

// Spinlock prevents multiple threads from creating multiple

// locks for the same new object.

// We could keep the nodes in some hash table if we find that there are

// more than 20 or so distinct locks active, but we don't do that now.

lockp->lock();

{

SyncData* p;

SyncData* firstUnused = NULL;

for (p = *listp; p != NULL; p = p->nextData) {

if ( p->object == object ) {

result = p;

// atomic because may collide with concurrent RELEASE

OSAtomicIncrement32Barrier(&result->threadCount);

goto done;

}

if ( (firstUnused == NULL) && (p->threadCount == 0) )

firstUnused = p;

}

// no SyncData currently associated with object

if ( (why == RELEASE) || (why == CHECK) )

goto done;

// an unused one was found, use it

if ( firstUnused != NULL ) {

result = firstUnused;

result->object = (objc_object *)object;

result->threadCount = 1;

goto done;

}

}

//

// malloc a new SyncData and add to list.

// XXX calling malloc with a global lock held is bad practice,

// might be worth releasing the lock, mallocing, and searching again.

// But since we never free these guys we won't be stuck in malloc very often.

result = (SyncData*)calloc(sizeof(SyncData), 1);

result->object = (objc_object *)object;

result->threadCount = 1;

new (&result->mutex) recursive_mutex_t(fork_unsafe_lock);

result->nextData = *listp;

*listp = result;

done:

lockp->unlock();

if (result) {

// Only new ACQUIRE should get here.

// All RELEASE and CHECK and recursive ACQUIRE are

// handled by the per-thread caches above.

if (why == RELEASE) {

// Probably some thread is incorrectly exiting

// while the object is held by another thread.

return nil;

}

if (why != ACQUIRE) _objc_fatal("id2data is buggy");

if (result->object != object) _objc_fatal("id2data is buggy");

#if SUPPORT_DIRECT_THREAD_KEYS

if (!fastCacheOccupied) {

// Save in fast thread cache

tls_set_direct(SYNC_DATA_DIRECT_KEY, result);

tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)1);

} else

#endif

{

// Save in thread cache

if (!cache) cache = fetch_cache(YES);

cache->list[cache->used].data = result;

cache->list[cache->used].lockCount = 1;

cache->used++;

}

}

return result;

}

BREAKPOINT_FUNCTION(

void objc_sync_nil(void)

);

int objc_sync_enter(id obj) //一个对象对应一把锁

{

int result = OBJC_SYNC_SUCCESS;

if (obj) {

SyncData* data = id2data(obj, ACQUIRE);

assert(data);

data->mutex.lock();

} else {

// @synchronized(nil) does nothing

if (DebugNilSync) {

_objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");

}

objc_sync_nil();

}

return result;

}

int objc_sync_exit(id obj)

{

int result = OBJC_SYNC_SUCCESS;

if (obj) {

SyncData* data = id2data(obj, RELEASE);

if (!data) {

result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;

} else {

bool okay = data->mutex.tryUnlock();

if (!okay) {

result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;

}

}

} else {

// @synchronized(nil) does nothing

}

return result;

}