process monitor crashes (#3010)

* Simplify locks with @synchronized

* Use threadsafe dicts for data and meta

Quicksilver/Code-QuickStepCore/QSObject.m

@@ -53,8 +53,8 @@ + (void)interfaceChanged {
 - (id)init {
  if (self = [super init]) {
 
- data = [NSMutableDictionary dictionaryWithCapacity:0];
- meta = [NSMutableDictionary dictionaryWithCapacity:0];
+ data = [QSThreadSafeMutableDictionary dictionaryWithCapacity:0];
+ meta = [QSThreadSafeMutableDictionary dictionaryWithCapacity:0];
  cache = [QSThreadSafeMutableDictionary dictionaryWithCapacity:0];
  name = nil;
  label = nil;

Quicksilver/Code-QuickStepFoundation/QSThreadSafeMutableDictionary.m

@@ -28,129 +28,127 @@
 
 #import "QSThreadSafeMutableDictionary.h"
 
-#import <libkern/OSAtomic.h>
-
-#define LOCKED(...) OSSpinLockLock(&_lock); \
-__VA_ARGS__; \
-OSSpinLockUnlock(&_lock);
+//#import <libkern/OSAtomic.h>
 
 @implementation QSThreadSafeMutableDictionary {
- OSSpinLock _lock;
- NSMutableDictionary *_dictionary; // Class Cluster!
+ NSMutableDictionary *_dictionary;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark - NSObject
 
 - (id)init {
- if ((self = [super init])) {
- _dictionary = [[NSMutableDictionary alloc] init];
- _lock = OS_SPINLOCK_INIT;
- }
- return self;
+ if ((self = [super init])) {
+ _dictionary = [[NSMutableDictionary alloc] init];
+ }
+ return self;
 }
 
 - (id)initWithObjects:(NSArray *)objects forKeys:(NSArray *)keys {
- if ((self = [self initWithCapacity:objects.count])) {
- [objects enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
- _dictionary[keys[idx]] = obj;
- }];
- }
- return self;
+ if ((self = [self initWithCapacity:objects.count])) {
+ [objects enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
+ _dictionary[keys[idx]] = obj;
+ }];
+ }
+ return self;
 }
 
 - (id)initWithCapacity:(NSUInteger)capacity {
- if ((self = [super init])) {
- _dictionary = [[NSMutableDictionary alloc] initWithCapacity:capacity];
- _lock = OS_SPINLOCK_INIT;
- }
- return self;
+ if ((self = [super init])) {
+ _dictionary = [[NSMutableDictionary alloc] initWithCapacity:capacity];
+ }
+ return self;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark - NSMutableDictionary
 
 - (void)setObject:(id)anObject forKey:(id<NSCopying>)aKey {
- LOCKED(_dictionary[aKey] = anObject)
+ @synchronized(_dictionary) { _dictionary[aKey] = anObject; }
 }
 
 - (void)addEntriesFromDictionary:(NSDictionary *)otherDictionary {
- LOCKED([_dictionary addEntriesFromDictionary:otherDictionary]);
+ @synchronized(_dictionary) { [_dictionary addEntriesFromDictionary:otherDictionary]; };
 }
 
 - (void)setDictionary:(NSDictionary *)otherDictionary {
- LOCKED([_dictionary setDictionary:otherDictionary]);
+ @synchronized(_dictionary) { [_dictionary setDictionary:otherDictionary]; };
 }
 
 - (void)removeObjectForKey:(id)aKey {
- LOCKED([_dictionary removeObjectForKey:aKey])
+ @synchronized(_dictionary) { [_dictionary removeObjectForKey:aKey]; }
 }
 
 - (void)removeAllObjects {
- LOCKED([_dictionary removeAllObjects]);
+ @synchronized(_dictionary) { [_dictionary removeAllObjects]; };
 }
 
 - (NSUInteger)count {
- LOCKED(NSUInteger count = _dictionary.count)
- return count;
+ @synchronized(_dictionary) {
+ NSUInteger count = _dictionary.count;
+ return count;}
 }
 
 - (NSArray *)allKeys {
- LOCKED(NSArray *allKeys = _dictionary.allKeys)
- return allKeys;
+ @synchronized(_dictionary) {
+ NSArray *allKeys = _dictionary.allKeys;
+ return allKeys;
+ }
 }
 
 - (NSArray *)allValues {
- LOCKED(NSArray *allValues = _dictionary.allValues)
- return allValues;
+ @synchronized(_dictionary) {
+ NSArray *allValues = _dictionary.allValues;
+ return allValues;
+ }
 }
 
 - (id)objectForKey:(id)aKey {
- LOCKED(id obj = _dictionary[aKey])
- return obj;
+ @synchronized(_dictionary) {
+ id obj = _dictionary[aKey];
+ return obj;
+ }
 }
 
 - (NSEnumerator *)keyEnumerator {
- LOCKED(NSEnumerator *keyEnumerator = [_dictionary keyEnumerator])
- return keyEnumerator;
+ @synchronized(_dictionary) {
+ NSEnumerator *keyEnumerator = [_dictionary keyEnumerator];
+ return keyEnumerator;
+ }
 }
 
 - (id)copyWithZone:(NSZone *)zone {
- return [self mutableCopyWithZone:zone];
+ return [self mutableCopyWithZone:zone];
 }
 
 - (id)mutableCopyWithZone:(NSZone *)zone {
- LOCKED(id copiedDictionary = [[self.class allocWithZone:zone] initWithDictionary:_dictionary])
- return copiedDictionary;
+ @synchronized(_dictionary) {
+ id copiedDictionary = [[self.class allocWithZone:zone] initWithDictionary:_dictionary];
+ return copiedDictionary;
+ }
 }
 
 - (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state
- objects:(id __unsafe_unretained [])stackbuf
- count:(NSUInteger)len {
- LOCKED(NSUInteger count = [[_dictionary copy] countByEnumeratingWithState:state objects:stackbuf count:len]);
- return count;
-}
-
-- (void)performLockedWithDictionary:(void (^)(NSDictionary *dictionary))block {
- if (block) {
- LOCKED(block(_dictionary));
- }
+ objects:(id __unsafe_unretained [])stackbuf
+ count:(NSUInteger)len {
+ @synchronized(_dictionary) {
+ NSUInteger count = [[_dictionary copy] countByEnumeratingWithState:state objects:stackbuf count:len];
+ return count;
+ };
 }
 
 - (BOOL)isEqual:(id)object {
- if (object == self) return YES;
-
- if ([object isKindOfClass:QSThreadSafeMutableDictionary.class]) {
- QSThreadSafeMutableDictionary *other = object;
- __block BOOL isEqual = NO;
- [other performLockedWithDictionary:^(NSDictionary *dictionary) {
- [self performLockedWithDictionary:^(NSDictionary *otherDictionary) {
- isEqual = [dictionary isEqual:otherDictionary];
- }];
- }];
- return isEqual;
- }
- return NO;
+ if (object == self) return YES;
+
+ if ([object isKindOfClass:QSThreadSafeMutableDictionary.class]) {
+ QSThreadSafeMutableDictionary *other = object;
+ @synchronized (_dictionary) {
+ @synchronized (other) {
+ return [_dictionary isEqual:other];
+ }
+ }
+ }
+ return NO;
 }
 
 @end