* Headers/Additions/GNUstepBase/GSLock.h: Added missing

forward declaration.
	* Headers/Additions/GNUstepBase/GSCategories.h: Remove
	declaraion of gnustep_global_lock.
	(GS_INITIALIZED_LOCK): New macro.
	(+[NSLock newLockAt:]): New method.
	(+[NSRecursiveLock newLockAt:]): Ditto.
	* Headers/Foundation/NSLock.h: Ditto.
	* Source/Additions/GSCategories.m: Replace global lock with
	local lock.
	(_GSLockInitializer): New class to initialize local lock
	safely.
	(newLockAt): New static function shared by +newLockAt:
	implementations to safely intialize lock variables.
	(+[NSLock newLockAt:]): Implemented and documented.
	(+[NSRecursiveLock newLockAt:]): Ditto.
	* Source/Additions/GSCompatibility.m: Remove
	gnustep_global_lock.
	* Source/Additions/GSObjCRuntime.m: Remove superfluous
	locking.
	* Source/Additions/Unicode.m: Use new GS_INITIALIZED_LOCK
	macro and replace global lock with local lock.
	* Source/NSLock.m
	(-[NSConditionLock lockWhenCondition:beforeDate:]):
	Implemented.
	* Testing/gslock.m: New test case.
	* Testing/GNUmakefile: Add new test case.


git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@18010 72102866-910b-0410-8b05-ffd578937521

Testing/GNUmakefile

@@ -36,6 +36,7 @@ CHECKABLE_TOOLS = \
 		call \
 		containers \
 		fref \
+		gslock \
 		nsarchiver \
 		nsarray \
 		nsattributedstring \
@@ -74,7 +75,8 @@ ADDITIONAL_TOOLS = \
 		nsconnection_client \
 		nsconnection_server \
 
-// TEST_TOOL_NAME += nsconnection_client nsconnection_server
+# TEST_TOOL_NAME += nsconnection_client nsconnection_server
+TEST_TOOL_NAME += nsconnection_client nsconnection_server $(ADDITIONAL_TOOLS)
 
 # The tool Objective-C source files to be compiled
 awake_OBJC_FILES = awake.m
@@ -84,6 +86,7 @@ call_OBJC_FILES = call.m
 containers_OBJC_FILES = containers.m
 diningPhilosophers_OBJC_FILES = diningPhilosophers.m
 fref_OBJC_FILES = fref.m
+gslock_OBJC_FILES = gslock.m
 gstcpport-client_OBJC_FILES = gstcpport-client.m
 gstcpport-server_OBJC_FILES = gstcpport-server.m
 nsarchiver_OBJC_FILES = nsarchiver.m

Testing/gslock.m

@@ -0,0 +1,227 @@
+/** gslock - Program to test GSLazyLocks.
+   Copyright (C) 2003 Free Software Foundation, Inc.
+
+   Written by:  David Ayers  <d.ayers@inode.at>
+
+   This file is part of the GNUstep Base Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+   
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with this library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
+*/
+
+
+#include <Foundation/NSAutoreleasePool.h>
+#include <Foundation/NSArray.h>
+#include <Foundation/NSValue.h>
+#include <Foundation/NSString.h>
+#include <Foundation/NSException.h>
+#include <Foundation/NSFileHandle.h>
+#include <Foundation/NSThread.h>
+
+#include <GNUstepBase/GSLock.h>
+
+NSLock          *lock = nil;
+
+NSLock              *gLock1 = nil;
+GSLazyRecursiveLock *gLock2 = nil;
+
+NSConditionLock     *cLock = nil;
+
+volatile int counter = 0;
+volatile int threadExitCounter;
+
+void
+wait_a_while()
+{
+  volatile int i;
+  for (i = 0; i < 5; i++)
+    i = ((i + 1) + (i - 1) / 2);
+}
+
+#define NUM_ITERATIONS 10000
+
+@interface Tester : NSObject
+- (void)runTest:(NSString *)ident;
+- (void)dummy:(id)none;
+- (void)createNewLockAt:(id)none;
+@end
+@implementation Tester
+- (void)dummy:(id)none
+{
+  NSLog(@"Multithreaded:%@",[NSThread currentThread]);
+}
+- (void)runTest:(NSString *)ident
+{
+  NSDate *start;
+  NSDate *end;
+  int i,j;
+  NSTimeInterval time = 0;
+  NSAutoreleasePool *pool;
+  BOOL makeMulti;
+
+  pool = [[NSAutoreleasePool alloc] init];
+
+  makeMulti = ([ident isEqualToString: @"Make Multithreaded GS"]);
+    
+  for (i = 0; i < 100; i++)
+    {
+      start = [NSDate date];
+      for (j = 0; j < NUM_ITERATIONS; j++)
+	{
+	  volatile int temp;
+
+	  [lock lock];
+
+	  temp = counter;
+	  wait_a_while();
+
+	  if (makeMulti && i == 49 )
+	    {
+	      [NSThread detachNewThreadSelector: @selector(dummy:)
+			toTarget: self
+			withObject: nil];
+	      makeMulti = NO;
+	    }
+
+
+	  counter =  temp + 1;
+	  wait_a_while();
+
+	  [lock unlock];
+	}
+      end = [NSDate date];
+      time += [end timeIntervalSinceDate: start];
+    }
+  NSLog(@"End (%@/%@/%@):%f ", 
+	[NSThread currentThread], ident, lock, time / 100 );
+
+  threadExitCounter++;
+
+  [pool release];
+}
+
+-(void)createNewLockAt:(id)none
+{
+  [cLock lock];
+
+  GS_INITIALIZED_LOCK(gLock1,NSLock);
+  GS_INITIALIZED_LOCK(gLock2,GSLazyRecursiveLock);
+
+  NSLog(@"Created locks: %@ %@", gLock1, gLock2);
+
+  [cLock unlockWithCondition: YES];
+}
+@end
+
+void
+test_lazyLocks()
+{
+  Tester *tester;
+  int i;
+
+  tester = [Tester new];
+
+  [tester runTest:@"empty"];
+
+  lock = [GSLazyLock new];
+  [tester runTest:@"single GS"];
+
+  lock = [GSLazyRecursiveLock new];
+  [tester runTest:@"single (r) GS"];
+
+  lock = [NSLock new];
+  [tester runTest:@"single NS"];
+
+  lock = [NSRecursiveLock new];
+  [tester runTest:@"single (r) NS"];
+
+  lock = [GSLazyLock new];
+  [tester runTest:@"Make Multithreaded GS"];
+
+  /* We are now multithreaded.  */
+  NSCAssert1 ([lock class] == [NSLock class],
+	      @"Class didn't morph:%@", lock);
+
+  lock = [GSLazyLock new];
+  NSCAssert1 ([lock class] == [NSLock class],
+	      @"Returned wrong lock:%@", lock);
+  /* These tests actually only test NS*Lock locking, but... */
+  [tester runTest:@"multi simple GS"];
+
+  lock = [GSLazyRecursiveLock new];
+  NSCAssert1 ([lock class] == [NSRecursiveLock class],
+	      @"Returned wrong lock:%@", lock);
+  [tester runTest:@"multi simple (r) GS"];
+
+  lock = [NSLock new];
+  [tester runTest:@"multi simple NS"];
+
+  lock = [NSRecursiveLock new];
+  [tester runTest:@"multi simple NS"];
+
+  /* Let's test locking anyway while we're at it. */
+  for (threadExitCounter = 0, i = 0; i < 3; i++)
+    {
+      NSString *ident;
+      ident = [NSString stringWithFormat: @"multi complex (%d)", i];
+      [NSThread detachNewThreadSelector: @selector(runTest:)
+		toTarget: tester
+		withObject: ident];
+    }
+
+  while (threadExitCounter < 3)
+    [NSThread sleepUntilDate: [NSDate dateWithTimeIntervalSinceNow: 10.0]];
+
+  NSCAssert1 (counter == NUM_ITERATIONS * 1300, 
+	      @"Locks broken! %d", counter );
+  
+}
+
+void
+test_newLockAt(void)
+{
+  Tester *t = [Tester new];
+
+  cLock = [[NSConditionLock alloc] initWithCondition: NO];
+
+  [NSThread detachNewThreadSelector: @selector(createNewLockAt:)
+	    toTarget: t
+	    withObject: nil];
+
+  [cLock lockWhenCondition: YES 
+	 beforeDate: [NSDate dateWithTimeIntervalSinceNow: 10.0]];
+  [cLock unlock];
+
+  NSCAssert1([gLock1 isKindOfClass: [NSLock class]],
+	     @"-[NSLock newLockAt:] returned %@", gLock1);
+  NSCAssert1([gLock2 isKindOfClass: [NSRecursiveLock class]],
+	     @"-[GSLazyRecursiveLock newLockAt:] returned %@", gLock1);
+
+}
+
+
+int
+main()
+{
+  NSAutoreleasePool *pool;
+  [NSAutoreleasePool enableDoubleReleaseCheck:YES];
+  pool = [[NSAutoreleasePool alloc] init];
+
+  test_lazyLocks();
+  test_newLockAt();
+
+  [pool release];
+
+  exit(0);
+}