Addresses #1765 Merge [12079] into main (pthreads-win32 for windows)

git-svn-id: file:///svn/toku/tokudb@12081 c7de825b-a66e-492c-adef-691d508d4ae1

db-benchmark-test/Makefile

@@ -127,11 +127,11 @@ OFILES = \
 	$(LIBPORTABILITY) \
 #end
 
-$(TARGET_TDB): db-benchmark-test.c
+$(TARGET_TDB): db-benchmark-test.c $(PTHREAD_LOCAL)
 	$(CC) $< $(BIN_FROM_C_FLAGS) $(OFILES) $(LINK_MUST_BE_LAST)
-$(SCANSCAN_TDB): scanscan.c
+$(SCANSCAN_TDB): scanscan.c $(PTHREAD_LOCAL)
 	$(CC) $< $(BIN_FROM_C_FLAGS) $(OFILES) $(LINK_MUST_BE_LAST)
-$(SCANRACE_TDB): scanrace.c
+$(SCANRACE_TDB): scanrace.c $(PTHREAD_LOCAL)
 	$(CC) $< $(BIN_FROM_C_FLAGS) $(OFILES) $(LINK_MUST_BE_LAST)
 
 else
@@ -141,14 +141,14 @@ $(TOKUDB): $(TOKUROOT)lib/$(TOKUDB)
 	cp $< $@
 $(TOKUROOT)lib/$(TOKUDB):
 	cd $(@D) && $(MAKE) $(@F).install
-$(TARGET_TDB) $(SCANSCAN_TDB) $(SCANRACE_TDB): $(TOKUDB)
+$(TARGET_TDB) $(SCANSCAN_TDB) $(SCANRACE_TDB): $(TOKUDB) $(PTHREAD_LOCAL)
 endif
 $(TARGET_TDB) $(SCANSCAN_TDB) $(SCANRACE_TDB): RPATH_DIRS=$(dir $(TDB_DLINK_FILES))
-$(TARGET_TDB): db-benchmark-test.c
+$(TARGET_TDB): db-benchmark-test.c $(PTHREAD_LOCAL)
 	$(CC) $< $(BIN_FROM_C_FLAGS) $(LINK_MUST_BE_LAST)
-$(SCANSCAN_TDB): scanscan.c
+$(SCANSCAN_TDB): scanscan.c $(PTHREAD_LOCAL)
 	$(CC) $< $(BIN_FROM_C_FLAGS) $(LINK_MUST_BE_LAST)
-$(SCANRACE_TDB): scanrace.c
+$(SCANRACE_TDB): scanrace.c $(PTHREAD_LOCAL)
 	$(CC) $< $(BIN_FROM_C_FLAGS) $(LINK_MUST_BE_LAST)
 endif
 

linux/linux.c

@@ -12,7 +12,7 @@
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <assert.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 
 int

linux/os_malloc.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <malloc.h>
 
 void *

newbrt/block_table.c

@@ -3,7 +3,7 @@
 #ident "Copyright (c) 2007, 2008, 2009 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "brt-internal.h"	// ugly but pragmatic, need access to dirty bits while holding translation lock
 #include "brttypes.h"
 #include "block_table.h"

newbrt/brt-serialize.c

@@ -567,7 +567,7 @@ struct decompress_work {
 static void init_decompress_work(struct decompress_work *w,
                                  void *compress_ptr, u_int32_t compress_size,
                                  void *uncompress_ptr, u_int32_t uncompress_size) {
-    w->id = 0;
+    memset(&w->id, 0, sizeof(w->id));
     w->compress_ptr = compress_ptr; w->compress_size = compress_size;
     w->uncompress_ptr = uncompress_ptr; w->uncompress_size = uncompress_size;
 }

newbrt/cachetable.c

@@ -9,7 +9,7 @@
 #include <malloc.h>
 #include <time.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "memory.h"
 #include "workqueue.h"
 #include "threadpool.h"

newbrt/checkpoint.c

@@ -47,7 +47,7 @@
  *
  *****/
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "brttypes.h"
 #include "cachetable.h"
 #include "checkpoint.h"

newbrt/compression-ratio/cratio.c

@@ -10,7 +10,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <zlib.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 
 
 toku_off_t fd_size (int fd) {

newbrt/includes.h

@@ -13,7 +13,7 @@
 
 // Portability first!
 #include "stdint.h"
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 
 #if TOKU_WINDOWS

newbrt/leafentry.h

@@ -30,7 +30,7 @@
  * The case of a committed pair and a provisional pair can be represented by a committed pair, since it doesn't matter whether the transction aborts or commits, the value is the same.
  */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "rbuf.h"
 #include "x1764.h"
 

newbrt/leaflock.c

@@ -3,7 +3,7 @@
 #ident "Copyright (c) 2007, 2008, 2009 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_pthread.h"
 #include "leaflock.h"
 #include "toku_assert.h"

newbrt/log.h

@@ -5,7 +5,7 @@
 #ident "Copyright (c) 2007, 2008, 2009 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <errno.h>
 
 #include "../include/db.h"

newbrt/logformat.c

@@ -11,7 +11,7 @@
  *   The struct definitions.
  *   The Latex documentation.
  */
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>

newbrt/minicron.c

@@ -2,7 +2,7 @@
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 #ident "$Id:$"
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <errno.h>
 #include <string.h>
 

newbrt/omt.c

@@ -3,7 +3,7 @@
 #ident "Copyright (c) 2007, 2008, 2009 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <ctype.h>
 #include <errno.h>
 #include <malloc.h>

newbrt/rbuf.h

@@ -5,7 +5,7 @@
 #ident "Copyright (c) 2007, 2008, 2009 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "memarena.h"
 #include "toku_assert.h"
 #include "brttypes.h"

newbrt/tests/Makefile

@@ -121,7 +121,7 @@ CHECKS = \
 #CHECKS will be defined automatically. 
 
 build: $(BINS)
-check: $(patsubst %,check_%,$(CHECKS))
+check: $(PTHREAD_LOCAL) $(patsubst %,check_%,$(CHECKS))
 
 check_fail:
 	test 0 = 1 $(SUMMARIZE_CMD)
@@ -136,23 +136,23 @@ check_test1305:
 	@echo SKIPPED SLOW TEST $@
 endif
 
-check_benchmarktest_256: benchmark-test$(BINSUF)
+check_benchmarktest_256: benchmark-test$(BINSUF) $(PTHREAD_LOCAL)
 	$(VGRIND) ./$< $(VERBVERBOSE) --valsize 256 --verify 1 $(SUMMARIZE_CMD)
 
-check_test-assertA: test-assert$(BINSUF)
+check_test-assertA: test-assert$(BINSUF) $(PTHREAD_LOCAL)
 	@# no arguments, should err
 	$(VGRIND) ./$< > /dev/null 2>&1 ; test $$? = 1 $(SUMMARIZE_CMD)
-check_test-assertB: test-assert$(BINSUF)
+check_test-assertB: test-assert$(BINSUF) $(PTHREAD_LOCAL)
 	@# one argument, not "ok" should err
 	@rm -f test-assert.out
 	($(VGRIND) ./$< notok) > test-assert.out 2>&1 ; test $$? = 1 && fgrep failed test-assert.out > /dev/null $(SUMMARIZE_CMD)
-check_test-assertC: test-assert$(BINSUF)
+check_test-assertC: test-assert$(BINSUF) $(PTHREAD_LOCAL)
 
-check_test-assert$(BINSUF): test-assert$(BINSUF)
+check_test-assert$(BINSUF): test-assert$(BINSUF) $(PTHREAD_LOCAL)
 	@# one argument, "ok" should not error
 	$(VGRIND) ./$< ok $(SUMMARIZE_CMD)
 
-check_%: %
+check_%: % $(PTHREAD_LOCAL)
 	$(VGRIND)  ./$< $(VERBVERBOSE) $(SUMMARIZE_CMD)
 
 benchmark-test.$(OEXT): ../brt.h ../brt-search.h ../../include/db.h

newbrt/tests/bread-test.c

@@ -2,7 +2,7 @@
  * See test_1305 for another bread test (testing to see if it can read 1GB files) */
 
 #include "test.h"
-#include "toku_portability.h"
+#include <toku_portability.h>
 
 #include <assert.h>
 #include <fcntl.h>

newbrt/tests/minicron-test.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "minicron.h"
 #include <unistd.h>
 #include <assert.h>

newbrt/tests/omt-cursor-test.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <errno.h>
 
 #include "test.h"

newbrt/tests/omt-test.c

@@ -2,7 +2,7 @@
 
 
 #include "test.h"
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <errno.h>
 #include <stdio.h>
 

newbrt/tests/test-leafentry.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <string.h>
 
 #include "test.h"

newbrt/tests/test.h

@@ -3,7 +3,7 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "brt.h"
 #include "toku_htonl.h"
 

newbrt/tests/test1305.c

 /* Test bread_backwards to make sure it can read backwards even for large files. */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 
 #include <fcntl.h>
 #include <stdlib.h>

newbrt/tests/test1308a.c

@@ -5,7 +5,7 @@
 #include <assert.h>
 #include <string.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "../brt.h" 
 
 #define FNAME "test1308a.data"

newbrt/tests/test_toku_malloc_plain_free.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "memory.h"
 #include "stdlib.h"
 

newbrt/tests/threadpool-test.c

@@ -6,7 +6,7 @@
 #include <errno.h>
 #include <malloc.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 #include "toku_pthread.h"
 #include "threadpool.h"

newbrt/tests/workqueue-test.c

@@ -2,7 +2,7 @@
 #include <errno.h>
 #include <string.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_assert.h"
 #include "toku_pthread.h"
 #include "memory.h"

newbrt/threadpool.c

@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <errno.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_pthread.h"
 #include "toku_assert.h"
 #include "memory.h"
@@ -27,7 +27,7 @@ int threadpool_create(THREADPOOL *threadpoolptr, int max_threads) {
     threadpool->current_threads = 0;
     int i;
     for (i=0; i<max_threads; i++)
-        threadpool->tids[i] = 0;
+        memset(&threadpool->tids[i], 0, sizeof(threadpool->tids[i]));
     *threadpoolptr = threadpool;
     return 0;
 }

newbrt/toku_worker.c

@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <errno.h>
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_assert.h"
 #include "toku_os.h"
 #include "toku_pthread.h"

newbrt/trace_mem.c

@@ -2,7 +2,7 @@
 #ident "Copyright (c) 2007, 2008, 2009 Tokutek Inc.  All rights reserved."
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "rdtsc.h"
 #include "trace_mem.h"
 

src/elocks.c

@@ -11,7 +11,7 @@
    every call (including methods) into the tokudb library gets the lock 
    no internal function should invoke a method through an object */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "ydb-internal.h"
 #include <assert.h>
 #include <toku_pthread.h>

src/errors.c

@@ -10,7 +10,7 @@
   The error handling routines for ydb
 */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <stdio.h>
 #include <stdarg.h>
 

src/lock_tree/db_id.c

@@ -3,7 +3,7 @@
 
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <errno.h>
 #include <assert.h>
 #include <string.h>

src/lock_tree/db_id.h

@@ -3,7 +3,7 @@
 
 #ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <brttypes.h>
 
 #if !defined(TOKU_DB_ID_H)

src/lock_tree/idlth.c

@@ -9,7 +9,7 @@
   
 */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <idlth.h>
 #include <assert.h>
 #include <errno.h>

src/lock_tree/locktree.c

@@ -8,7 +8,7 @@
    \brief Lock trees: implementation
 */
   
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <locktree.h>
 #include <ydb-internal.h>
 #include <brt-internal.h>

src/lock_tree/lth.c

@@ -9,7 +9,7 @@
   
 */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "lth.h"
 #include <assert.h>
 #include <errno.h>

src/lock_tree/rth.c

@@ -9,7 +9,7 @@
   
 */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "rth.h"
 #include <assert.h>
 #include <errno.h>

src/lock_tree/tests/test.h

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <string.h>
 #include <locktree.h>
 #include <db.h>

src/lock_tree/tests/test_00070_ltm.c

 /* Test for a memory leak from just closing the lock tree manager (should close
    all lock trees. */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <fcntl.h>
 #include "test.h"
 #include <unistd.h>

src/lock_tree/tests/test_00080_lt_refcount.c

 /* Test for a memory leak from just closing the lock tree manager (should close
    all lock trees. */
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <fcntl.h>
 #include "test.h"
 #include <unistd.h>

src/range_tree/rangetree.h

@@ -19,7 +19,7 @@
 */
 
 //Defines BOOL data type.
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <brttypes.h>
 #include <db.h>
 

src/tests/Makefile

@@ -201,7 +201,7 @@ tests: tests.bdb tests.tdb ;
 tests.bdb: $(BDB_TESTS) ;
 check.bdb: $(RUN_BDB_TESTS) ;
 tests.tdb: $(TDB_TESTS) ;
-check.tdb: $(notdir $(LIBTDB)) $(RUN_TDB_TESTS) ;
+check.tdb: $(notdir $(LIBTDB)) $(PTHREAD_LOCAL) $(RUN_TDB_TESTS) ;
 
 foo:
 	echo RUN_TDB_TESTS: $(RUN_TDB_TESTS)
@@ -257,7 +257,7 @@ endif
 # Use -s on the command line to make things quiet.
 %.bdbrun: %.bdb$(BINSUF) $(DEPEND_COMPILE) $(DEPEND_LINK) $(WINDOWS_BDB_LIB_NAME)
 	$(BDBVGRIND) ./$< $(VERBVERBOSE) $(MAYBEINVERTER) $(SUMMARIZE_CMD)
-%.tdbrun: %.tdb$(BINSUF) $(DEPEND_COMPILE) $(DEPEND_LINK) $(notdir $(LIBTDB))
+%.tdbrun: %.tdb$(BINSUF) $(DEPEND_COMPILE) $(DEPEND_LINK) $(notdir $(LIBTDB)) $(PTHREAD_LOCAL)
 	$(TDBVGRIND) ./$< $(VERBVERBOSE) $(MAYBEINVERTER) $(SUMMARIZE_CMD)
 
 ifeq ($(OS_CHOICE),windows)
@@ -268,8 +268,7 @@ else
     TDBLOAD=$(TOKUROOT)utils/tokudb_load_static$(BINSUF)
 endif
 
-
-%.recover: %.tdb$(BINSUF)
+%.recover: %.tdb$(BINSUF) $(PTHREAD_LOCAL)
 	echo doing ./$< &&\
 	$(VGRIND) ./$<                                                                          && \
 	rm -rf dir.$*.c.tdb.recover                                                             && \
@@ -282,11 +281,11 @@ endif
 	diff -q dir.$*.c.tdb/foo.dump dir.$*.c.tdb.recover/foo.dump                                   \
 	$(MAYBEINVERTER) $(SUMMARIZE_CMD)
 
-%.recoverwc: %.tdb$(BINSUF)
+%.recoverwc: %.tdb$(BINSUF) $(PTHREAD_LOCAL)
 	 (cd dir.$*.c.tdb;pwd;cat log*| ../../../newbrt/tdb_logprint |wc -c)
 
 .PHONY: %.recover
-all.recover: $(patsubst %,test_log%.recover,$(TLRECOVER)) ;
+all.recover: $(patsubst %,test_log%.recover,$(TLRECOVER)) $(PTHREAD_LOCAL) ;
 
 #DISABLE standard tdbrun for recover tests.
 $(patsubst %,test_log%.tdbrun,$(TLRECOVER)): ;
@@ -422,11 +421,11 @@ test_get_both_range.tdbrun: \
  # intentionally blank line
 	true $(SUMMARIZE_CMD) #State that this has passed.
 
-tgbr_%_a.tdbrun: test_get_both_range.tdb$(BINSUF)
+tgbr_%_a.tdbrun: test_get_both_range.tdb$(BINSUF) $(PTHREAD_LOCAL)
 	$(VGRIND) ./$< $(VERBVERBOSE) -i $* -a $(MAYBEINVERTER) $(SUMMARIZE_CMD)
-tgbr_%_b.tdbrun: test_get_both_range.tdb$(BINSUF)
+tgbr_%_b.tdbrun: test_get_both_range.tdb$(BINSUF) $(PTHREAD_LOCAL)
 	$(VGRIND) ./$< $(VERBVERBOSE) -i $* -b $(MAYBEINVERTER) $(SUMMARIZE_CMD)
-tgbr_%_c.tdbrun: test_get_both_range.tdb$(BINSUF)
+tgbr_%_c.tdbrun: test_get_both_range.tdb$(BINSUF) $(PTHREAD_LOCAL)
 	$(VGRIND) ./$< $(VERBVERBOSE) -i $* -c $(MAYBEINVERTER) $(SUMMARIZE_CMD)
 
 ifeq ($(OS_CHOICE),windows)
@@ -442,7 +441,7 @@ dump.bdb.1426: test1426.bdb$(BINSUF) test1426.bdbdump/dump.bdb.1426
 endif
 
 # test1426 is run by comparing the BDB output to the TDB output
-test1426.tdbrun: test1426.tdb$(BINSUF) dump.bdb.1426
+test1426.tdbrun: test1426.tdb$(BINSUF) dump.bdb.1426 $(PTHREAD_LOCAL)
 	(./test1426.tdb$(BINSUF) -q && \
 	 $(TDBDUMP) -p -h dir.test1426.c.tdb main > dump.tdb.1426 && \
 	 diff -q -I db_pagesize=4096 dump.bdb.1426 dump.tdb.1426 ) \
@@ -452,7 +451,7 @@ test1426.tdbrun: test1426.tdb$(BINSUF) dump.bdb.1426
 STRESS_RUNS=5
 STRESS_SIZE=5001
 checkpoint_stress.tdbrun: SHELL=/bin/bash
-checkpoint_stress.tdbrun: checkpoint_stress.tdb$(BINSUF)
+checkpoint_stress.tdbrun: checkpoint_stress.tdb$(BINSUF) $(PTHREAD_LOCAL)
 	$(VGRIND) ./$< -C -n $(STRESS_SIZE) $(VERBVERBOSE) && \
 	($(VGRIND) ./$< -C -i 0 -n $(STRESS_SIZE) $(VERBVERBOSE) && \
 	 for (( i = 1; i < $(STRESS_RUNS); i++ )); do \
@@ -475,6 +474,6 @@ dumpit:
 	../../newbrt/brtdump  dir.test_log5.c.tdb.recover/foo.db > dump.r && ../../newbrt/brtdump  dir.test_log5.c.tdb/foo.db > dump.o && diff -q dump.o dump.r
 
 # test on small stacks
-test_thread_stack.%run: test_thread_stack.%$(BINSUF)
+test_thread_stack.%run: test_thread_stack.%$(BINSUF) $(PTHREAD_LOCAL)
 	./$< -a -thread_stack 16384         && \
 	./$< -a -thread_stack 16384 -resume $(SUMMARIZE_CMD)

src/tests/test_dbremove_old.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."
 #include "test.h"
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <fcntl.h>
 #include <errno.h>
 

src/tests/test_thread_insert.c

@@ -33,13 +33,19 @@ db_put (DB *db, my_t k, my_t v) {
 static void *
 do_inserts (void *arg) {
     struct db_inserter *mywork = (struct db_inserter *) arg;
-    if (verbose) printf("%lu:%u:do_inserts:start:%u-%u\n", (unsigned long)toku_pthread_self(), getmyid(), mywork->startno, mywork->endno);
+    if (verbose) {
+        toku_pthread_t self = toku_pthread_self();
+        printf("%lu:%u:do_inserts:start:%u-%u\n", *(unsigned long*)&self, getmyid(), mywork->startno, mywork->endno);
+    }
     my_t i;
     for (i=mywork->startno; i < mywork->endno; i++) {
         int r = db_put(mywork->db, htonl(i), i); assert(r == 0);
     }
     
-    if (verbose) printf("%lu:%u:do_inserts:end\n", (unsigned long)toku_pthread_self(), getmyid());
+    if (verbose) {
+        toku_pthread_t self = toku_pthread_self();
+        printf("%lu:%u:do_inserts:end\n", *(unsigned long*)&self, getmyid());
+    }
     // Don't call toku_pthread_exit(), since it has a memory leak.
     // if (mywork->do_exit) toku_pthread_exit(arg);
     return 0;

src/tests/test_thread_stack.c

@@ -29,13 +29,19 @@ db_put (DB *db, my_t k, my_t v) {
 static void *
 do_inserts (void *arg) {
     struct db_inserter *mywork = (struct db_inserter *) arg;
-    if (verbose) printf("%lu:%d:do_inserts:start:%u-%u\n", (unsigned long)toku_pthread_self(), toku_os_gettid(), mywork->startno, mywork->endno);
+    if (verbose) {
+        toku_pthread_t self = toku_pthread_self();
+        printf("%lu:%d:do_inserts:start:%u-%u\n", *(unsigned long*)&self, toku_os_gettid(), mywork->startno, mywork->endno);
+    }
     my_t i;
     for (i=mywork->startno; i < mywork->endno; i++) {
         int r = db_put(mywork->db, htonl(i), i); assert(r == 0);
     }
     
-    if (verbose) printf("%lu:%d:do_inserts:end\n", (unsigned long)toku_pthread_self(), toku_os_gettid());
+    if (verbose) {
+        toku_pthread_t self = toku_pthread_self();
+        printf("%lu:%d:do_inserts:end\n", *(unsigned long*)&self, toku_os_gettid());
+    }
     if (mywork->do_exit) return arg;
     return 0;
 }

src/ydb.c

@@ -6,7 +6,7 @@
 const char *toku_patent_string = "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it.";
 const char *toku_copyright_string = "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved.";
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <toku_pthread.h>
 #include <ctype.h>
 #include <errno.h>

toku_include/Makefile.include

@@ -230,7 +230,7 @@ ifneq ($(CYGWIN),)
 	    CRUNTIME=MTd
 	endif
 	endif
-        ALWAYS_LINK=$(LIBPORTABILITY) $(TOKUROOT)windows/lib/$(CRUNTIME)/zlib.lib Ws2_32.lib psapi.lib
+        ALWAYS_LINK=$(LIBPORTABILITY) $(TOKUROOT)windows/lib/$(CRUNTIME)/pthreadVC2.lib $(TOKUROOT)windows/lib/$(CRUNTIME)/zlib.lib Ws2_32.lib psapi.lib
         LINK=#Empty
         BINOUTPUT=-Fe
         OOUTPUT=-Fo
@@ -241,7 +241,7 @@ ifneq ($(CYGWIN),)
         WRONGAEXT=a
         SOEXT=dll
         WRONGSOEXT=so
-        C99       = -Qstd=c99
+        C99       = -Qstd=c99 -Qvc9
         OPT_OPTFLAGS = -Ox -Qip -Qipo1
         DBG_OPTFLAGS = -Od
         COMBINE_C = -Qipo-c
@@ -387,6 +387,17 @@ $(NOIPO_YDB) $(IPO_YDB): $(@D)*.[ch]
 	cd $(@D) && $(MAKE) $(@F)
 endif
 
+ifeq ($(OS_CHOICE),windows)
+PTHREAD_LIB=$(TOKUROOT)windows/lib/$(CRUNTIME)/pthreadVC2.dll
+PTHREAD_LOCAL=$(notdir $(PTHREAD_LIB))
+
+$(PTHREAD_LOCAL): $(PTHREAD_LIB)
+	cp $< $@
+else
+PTHREAD_LOCAL=
+endif
+
+
 BIN_FROM_C_FLAGS      =$(CFLAGS) $(CPPFLAGS)    $(LDFLAGS)       $(BINOUTPUT)$@
 BIN_FROM_C_FLAGS_NOLIB=$(CFLAGS) $(CPPFLAGS)    $(LDFLAGS_NOLIB) $(BINOUTPUT)$@
 %$(BINSUF):%.c       $(DEPEND_COMPILE) $(DEPEND_LINK)

windows/env.c

+#include <toku_portability.h>
 #include <windows.h>
 #include <toku_stdlib.h>
-#include "toku_portability.h"
 #include <assert.h>
 
 int

windows/memory.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "memory.h"
 #include <string.h>
 #include <stdlib.h>

windows/os_malloc.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <stdlib.h>
 
 #include <string.h>

windows/sched.h

+/*
+ * Module: sched.h
+ *
+ * Purpose:
+ *      Provides an implementation of POSIX realtime extensions
+ *      as defined in 
+ *
+ *              POSIX 1003.1b-1993      (POSIX.1b)
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads-win32 - POSIX Threads Library for Win32
+ *      Copyright(C) 1998 John E. Bossom
+ *      Copyright(C) 1999,2005 Pthreads-win32 contributors
+ * 
+ *      Contact Email: rpj@callisto.canberra.edu.au
+ * 
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *      http://sources.redhat.com/pthreads-win32/contributors.html
+ * 
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser 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
+ *      Lesser General Public License for more details.
+ * 
+ *      You should have received a copy of the GNU Lesser General Public
+ *      License along with this library in the file COPYING.LIB;
+ *      if not, write to the Free Software Foundation, Inc.,
+ *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#ifndef _SCHED_H
+#define _SCHED_H
+
+#undef PTW32_LEVEL
+
+#if defined(_POSIX_SOURCE)
+#define PTW32_LEVEL 0
+/* Early POSIX */
+#endif
+
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
+#undef PTW32_LEVEL
+#define PTW32_LEVEL 1
+/* Include 1b, 1c and 1d */
+#endif
+
+#if defined(INCLUDE_NP)
+#undef PTW32_LEVEL
+#define PTW32_LEVEL 2
+/* Include Non-Portable extensions */
+#endif
+
+#define PTW32_LEVEL_MAX 3
+
+#if !defined(PTW32_LEVEL)
+#define PTW32_LEVEL PTW32_LEVEL_MAX
+/* Include everything */
+#endif
+
+
+#if __GNUC__ && ! defined (__declspec)
+# error Please upgrade your GNU compiler to one that supports __declspec.
+#endif
+
+/*
+ * When building the DLL code, you should define PTW32_BUILD so that
+ * the variables/functions are exported correctly. When using the DLL,
+ * do NOT define PTW32_BUILD, and then the variables/functions will
+ * be imported correctly.
+ */
+#ifndef PTW32_STATIC_LIB
+#  ifdef PTW32_BUILD
+#    define PTW32_DLLPORT __declspec (dllexport)
+#  else
+#    define PTW32_DLLPORT __declspec (dllimport)
+#  endif
+#else
+#  define PTW32_DLLPORT
+#endif
+
+/*
+ * This is a duplicate of what is in the autoconf config.h,
+ * which is only used when building the pthread-win32 libraries.
+ */
+
+#ifndef PTW32_CONFIG_H
+#  if defined(WINCE)
+#    define NEED_ERRNO
+#    define NEED_SEM
+#  endif
+#  if defined(_UWIN) || defined(__MINGW32__)
+#    define HAVE_MODE_T
+#  endif
+#endif
+
+/*
+ *
+ */
+
+#if PTW32_LEVEL >= PTW32_LEVEL_MAX
+#ifdef NEED_ERRNO
+#include "need_errno.h"
+#else
+#include <errno.h>
+#endif
+#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
+
+#if defined(__MINGW32__) || defined(_UWIN)
+#if PTW32_LEVEL >= PTW32_LEVEL_MAX
+/* For pid_t */
+#  include <sys/types.h>
+/* Required by Unix 98 */
+#  include <time.h>
+#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
+#else
+typedef int pid_t;
+#endif
+
+/* Thread scheduling policies */
+
+enum {
+  SCHED_OTHER = 0,
+  SCHED_FIFO,
+  SCHED_RR,
+  SCHED_MIN   = SCHED_OTHER,
+  SCHED_MAX   = SCHED_RR
+};
+
+struct sched_param {
+  int sched_priority;
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+PTW32_DLLPORT int __cdecl sched_yield (void);
+
+PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy);
+
+PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy);
+
+PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy);
+
+PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid);
+
+/*
+ * Note that this macro returns ENOTSUP rather than
+ * ENOSYS as might be expected. However, returning ENOSYS
+ * should mean that sched_get_priority_{min,max} are
+ * not implemented as well as sched_rr_get_interval.
+ * This is not the case, since we just don't support
+ * round-robin scheduling. Therefore I have chosen to
+ * return the same value as sched_setscheduler when
+ * SCHED_RR is passed to it.
+ */
+#define sched_rr_get_interval(_pid, _interval) \
+  ( errno = ENOTSUP, (int) -1 )
+
+
+#ifdef __cplusplus
+}                               /* End of extern "C" */
+#endif                          /* __cplusplus */
+
+#undef PTW32_LEVEL
+#undef PTW32_LEVEL_MAX
+
+#endif                          /* !_SCHED_H */
+

windows/semaphore.h

+/*
+ * Module: semaphore.h
+ *
+ * Purpose:
+ *	Semaphores aren't actually part of the PThreads standard.
+ *	They are defined by the POSIX Standard:
+ *
+ *		POSIX 1003.1b-1993	(POSIX.1b)
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads-win32 - POSIX Threads Library for Win32
+ *      Copyright(C) 1998 John E. Bossom
+ *      Copyright(C) 1999,2005 Pthreads-win32 contributors
+ * 
+ *      Contact Email: rpj@callisto.canberra.edu.au
+ * 
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *      http://sources.redhat.com/pthreads-win32/contributors.html
+ * 
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser 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
+ *      Lesser General Public License for more details.
+ * 
+ *      You should have received a copy of the GNU Lesser General Public
+ *      License along with this library in the file COPYING.LIB;
+ *      if not, write to the Free Software Foundation, Inc.,
+ *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined( SEMAPHORE_H )
+#define SEMAPHORE_H
+
+#undef PTW32_LEVEL
+
+#if defined(_POSIX_SOURCE)
+#define PTW32_LEVEL 0
+/* Early POSIX */
+#endif
+
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
+#undef PTW32_LEVEL
+#define PTW32_LEVEL 1
+/* Include 1b, 1c and 1d */
+#endif
+
+#if defined(INCLUDE_NP)
+#undef PTW32_LEVEL
+#define PTW32_LEVEL 2
+/* Include Non-Portable extensions */
+#endif
+
+#define PTW32_LEVEL_MAX 3
+
+#if !defined(PTW32_LEVEL)
+#define PTW32_LEVEL PTW32_LEVEL_MAX
+/* Include everything */
+#endif
+
+#if __GNUC__ && ! defined (__declspec)
+# error Please upgrade your GNU compiler to one that supports __declspec.
+#endif
+
+/*
+ * When building the DLL code, you should define PTW32_BUILD so that
+ * the variables/functions are exported correctly. When using the DLL,
+ * do NOT define PTW32_BUILD, and then the variables/functions will
+ * be imported correctly.
+ */
+#ifndef PTW32_STATIC_LIB
+#  ifdef PTW32_BUILD
+#    define PTW32_DLLPORT __declspec (dllexport)
+#  else
+#    define PTW32_DLLPORT __declspec (dllimport)
+#  endif
+#else
+#  define PTW32_DLLPORT
+#endif
+
+/*
+ * This is a duplicate of what is in the autoconf config.h,
+ * which is only used when building the pthread-win32 libraries.
+ */
+
+#ifndef PTW32_CONFIG_H
+#  if defined(WINCE)
+#    define NEED_ERRNO
+#    define NEED_SEM
+#  endif
+#  if defined(_UWIN) || defined(__MINGW32__)
+#    define HAVE_MODE_T
+#  endif
+#endif
+
+/*
+ *
+ */
+
+#if PTW32_LEVEL >= PTW32_LEVEL_MAX
+#ifdef NEED_ERRNO
+#include "need_errno.h"
+#else
+#include <errno.h>
+#endif
+#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
+
+#define _POSIX_SEMAPHORES
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+#ifndef HAVE_MODE_T
+typedef unsigned int mode_t;
+#endif
+
+
+typedef struct sem_t_ * sem_t;
+
+PTW32_DLLPORT int __cdecl sem_init (sem_t * sem,
+			    int pshared,
+			    unsigned int value);
+
+PTW32_DLLPORT int __cdecl sem_destroy (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_trywait (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_wait (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_timedwait (sem_t * sem,
+				 const struct timespec * abstime);
+
+PTW32_DLLPORT int __cdecl sem_post (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_post_multiple (sem_t * sem,
+				     int count);
+
+PTW32_DLLPORT int __cdecl sem_open (const char * name,
+			    int oflag,
+			    mode_t mode,
+			    unsigned int value);
+
+PTW32_DLLPORT int __cdecl sem_close (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_unlink (const char * name);
+
+PTW32_DLLPORT int __cdecl sem_getvalue (sem_t * sem,
+				int * sval);
+
+#ifdef __cplusplus
+}				/* End of extern "C" */
+#endif				/* __cplusplus */
+
+#undef PTW32_LEVEL
+#undef PTW32_LEVEL_MAX
+
+#endif				/* !SEMAPHORE_H */

windows/tests/Makefile

@@ -21,7 +21,7 @@ all: $(BINS)
 .PHONY: check
 check: $(BINS) $(RUNTARGETS);
 
-%.tdbrun: %$(BINSUF)
+%.tdbrun: %$(BINSUF) $(PTHREAD_LOCAL)
 	mkdir -p dir.$*
 ifeq ($(VGRIND),)
 	cd dir.$* && ../$< $(SUMMARIZE_CMD)

windows/tests/test-dirs.c

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <assert.h>
 #include <fcntl.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 #include <dirent.h>
 

windows/tests/test-fileid.c

@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <fcntl.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 
 int verbose=0;

windows/tests/test-pread.c

@@ -2,7 +2,7 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <fcntl.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 
 int verbose;

windows/tests/test-pthread-cond.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>

windows/tests/test-pthread-create.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>

windows/tests/test-pthread-handle-leak.c

 // test for a pthread handle leak
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>

windows/tests/test-pwrite4g.c

 /* Verify that toku_os_pwrite does the right thing when writing beyond 4GB.  */
 #include <fcntl.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <assert.h>
 
 int main (int argc __attribute__((__unused__)), char *argv[] __attribute__((__unused__))) {

windows/tests/test-snprintf.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>

windows/tests/test-strtoll.c

 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_os.h"
 
 int verbose;

windows/tests/test-unique-fileid.c

@@ -2,7 +2,7 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <fcntl.h>
-#include "toku_portability.h"
+#include <toku_portability.h>
 
 int main(void) {
     int r;

windows/toku_assert.c

-#include "toku_portability.h"
+#include <toku_portability.h>
 #include "toku_assert.h"
 
 #include <stdlib.h>

windows/toku_pthread.c

 #include <toku_portability.h>
 #include <windows.h>
-#include <assert.h>
-#include <errno.h>
 #include <toku_pthread.h>
-#include "memory.h"
-
-int
-toku_pthread_rwlock_init(toku_pthread_rwlock_t *restrict rwlock, const toku_pthread_rwlockattr_t *restrict attr) {
-    assert(attr == NULL);
-    // assert(!rwlock->initialized);
-    int r = toku_pthread_mutex_init(&rwlock->mutex, NULL);
-    if (r==0) {
-        rwlock_init(&rwlock->rwlock);
-        rwlock->initialized = TRUE;
-    }
-    return r;
-}
-
-int
-toku_pthread_rwlock_destroy(toku_pthread_rwlock_t *rwlock) {
-    assert(rwlock->initialized);
-    int r = toku_pthread_mutex_destroy(&rwlock->mutex);
-    if (r==0) {
-        rwlock_destroy(&rwlock->rwlock);
-        rwlock->initialized = FALSE;
-    }
-    return r;
-}
-
-int
-toku_pthread_rwlock_rdlock(toku_pthread_rwlock_t *rwlock) {
-    assert(rwlock->initialized);
-    int r;
-    r = toku_pthread_mutex_lock(&rwlock->mutex);
-    assert(r==0);
-    rwlock_read_lock(&rwlock->rwlock, &rwlock->mutex);
-    r = toku_pthread_mutex_unlock(&rwlock->mutex);
-    assert(r==0);
-    return r;
-}
-
-int
-toku_pthread_rwlock_rdunlock(toku_pthread_rwlock_t *rwlock) {
-    assert(rwlock->initialized);
-    int r;
-    r = toku_pthread_mutex_lock(&rwlock->mutex);
-    assert(r==0);
-    rwlock_read_unlock(&rwlock->rwlock);
-    r = toku_pthread_mutex_unlock(&rwlock->mutex);
-    assert(r==0);
-    return r;
-}
-
-int
-toku_pthread_rwlock_wrlock(toku_pthread_rwlock_t *rwlock) {
-    assert(rwlock->initialized);
-    int r;
-    r = toku_pthread_mutex_lock(&rwlock->mutex);
-    assert(r==0);
-    rwlock_write_lock(&rwlock->rwlock, &rwlock->mutex);
-    r = toku_pthread_mutex_unlock(&rwlock->mutex);
-    assert(r==0);
-    return r;
-}
-
-int
-toku_pthread_rwlock_wrunlock(toku_pthread_rwlock_t *rwlock) {
-    assert(rwlock->initialized);
-    int r;
-    r = toku_pthread_mutex_lock(&rwlock->mutex);
-    assert(r==0);
-    rwlock_write_unlock(&rwlock->rwlock);
-    r = toku_pthread_mutex_unlock(&rwlock->mutex);
-    assert(r==0);
-    return r;
-}
-
-int
-toku_pthread_mutex_init(toku_pthread_mutex_t *mutex, const toku_pthread_mutexattr_t *attr) {
-    assert(attr == NULL);
-    // assert(!mutex->initialized);
-    InitializeCriticalSection(&mutex->section);
-    mutex->initialized = TRUE;
-    return 0;
-}
-
-int
-toku_pthread_mutex_destroy(toku_pthread_mutex_t *mutex) {
-    assert(mutex->initialized);
-    DeleteCriticalSection(&mutex->section);
-    mutex->initialized = FALSE;
-    return 0;
-}
-
-int
-toku_pthread_mutex_lock(toku_pthread_mutex_t *mutex) {
-    assert(mutex->initialized);
-    EnterCriticalSection(&mutex->section);
-    return 0;
-}
-
-#if 0
-int
-toku_pthread_mutex_trylock(toku_pthread_mutex_t *mutex) {
-    assert(mutex->initialized);
-    int r = 0;
-    if (!TryEnterCriticalSection(&mutex->section))
-        r = EBUSY;
-    return r;
-}
-#endif
-
-int
-toku_pthread_mutex_unlock(toku_pthread_mutex_t *mutex) {
-    assert(mutex->initialized);
-    LeaveCriticalSection(&mutex->section);
-    return 0;
-}
-
-int
-toku_pthread_attr_init(toku_pthread_attr_t *attr) {
-    attr->stacksize = 0;
-    return 0;
-}
-
-int 
-toku_pthread_attr_destroy(toku_pthread_attr_t *attr) {
-    attr = attr;
-    return 0;
-}
-
-int 
-toku_pthread_attr_setstacksize(toku_pthread_attr_t *attr, size_t stacksize) {
-    attr->stacksize = stacksize;
-    return 0;
-}
-
-int 
-toku_pthread_attr_getstacksize(toku_pthread_attr_t *attr, size_t *stacksize) {
-    *stacksize = attr->stacksize;
-    return 0;
-}
-
-
-static DWORD WINAPI 
-toku_pthread_start(LPVOID a) {
-    toku_pthread_t thread = (toku_pthread_t) a;
-    thread->ret = thread->f(thread->arg);
-    return 0;
-}
-
-int 
-toku_pthread_create(toku_pthread_t *threadptr, const toku_pthread_attr_t *attr, void *(*f)(void *), void *arg) {
-    size_t stacksize = 0;
-    toku_pthread_t thread = toku_malloc(sizeof (struct toku_pthread));
-    if (thread == 0) 
-        return ENOMEM;
-    if (attr)
-        stacksize = attr->stacksize;
-    thread->f = f;
-    thread->arg = arg;
-    // _beginthread or CreateThread
-    thread->handle = CreateThread(NULL, stacksize, toku_pthread_start, thread, 0, &thread->id);
-    if (thread->handle == NULL) {
-	toku_free(thread);
-	return ENOMEM;
-    }
-    *threadptr = thread;
-    return 0;
-}
-
-int 
-toku_pthread_join(toku_pthread_t thread, void **ret) {
-    DWORD r;
-    r = WaitForSingleObject(thread->handle, INFINITE);
-    assert(r != WAIT_FAILED);
-    if (ret)
-        *ret = thread->ret;
-    BOOL b;
-    b = CloseHandle(thread->handle); assert(b != 0);
-    toku_free(thread);
-    return 0;
-}
-
-toku_pthread_t
-toku_pthread_self(void) {
-    // lookup a pthread by thread id and return it
-    return 0;
-}
-
-#if 0
-void
-toku_pthread_exit(void *ret) {
-    toku_pthread_t self = toku_pthread_self();
-    thread->ret = ret;
-    // _endthread or ExitThread
-    ExitThread(0);
-}
-#endif
-
-int 
-toku_pthread_cond_init(toku_pthread_cond_t *cond, const toku_pthread_condattr_t *attr) {
-    int r;
-    assert(attr == 0);
-    cond->events[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
-    if (cond->events[0] == NULL)
-        return GetLastError();
-    cond->events[1] = CreateEvent(NULL, TRUE, FALSE, NULL);
-    if (cond->events[1] == NULL) {
-        r = GetLastError();
-        CloseHandle(cond->events[0]);
-        return r;
-    }
-    cond->waiters = 0;
-    return 0;
-}
-
-int 
-toku_pthread_cond_destroy(toku_pthread_cond_t *cond) {
-    int i;
-    for (i=0; i<TOKU_PTHREAD_COND_NEVENTS; i++)
-        CloseHandle(cond->events[i]);
-    return 0;
-}
-
-int 
-toku_pthread_cond_wait(toku_pthread_cond_t *cond, toku_pthread_mutex_t *mutex) {
-    DWORD r;
-    cond->waiters++;
-    toku_pthread_mutex_unlock(mutex);
-    r = WaitForMultipleObjects(TOKU_PTHREAD_COND_NEVENTS, cond->events, FALSE, INFINITE);
-    assert(r!=WAIT_FAILED);
-    toku_pthread_mutex_lock(mutex);
-    cond->waiters--;
-    if (cond->waiters == 0 && r == WAIT_OBJECT_0 + 1)
-        ResetEvent(cond->events[1]);
-    return 0;
-}
-
-int toku_pthread_cond_timedwait(toku_pthread_cond_t *cond, toku_pthread_mutex_t *mutex, toku_timespec_t *wakeup_at) {
-    toku_timespec_t current;
-    int rclock = clock_gettime(CLOCK_REALTIME, &current);
-    assert(rclock==0);
-    int64_t milliseconds_wakeup = wakeup_at->tv_sec * 1000 + wakeup_at->tv_nsec / 1000000;
-    int64_t milliseconds_current = wakeup_at->tv_sec * 1000 + wakeup_at->tv_nsec / 1000000;
-    int64_t milli_diff = milliseconds_wakeup - milliseconds_current;
-    DWORD milliseconds_wait;
-    if (milli_diff <= 0) milliseconds_wait = 1; //Never sleep for 0.
-    else                milliseconds_wait = milli_diff;
-
-    DWORD r;
-    cond->waiters++;
-    toku_pthread_mutex_unlock(mutex);
-    r = WaitForMultipleObjects(TOKU_PTHREAD_COND_NEVENTS, cond->events, FALSE, milliseconds_wait);
-    assert(r!=WAIT_FAILED);
-    toku_pthread_mutex_lock(mutex);
-    cond->waiters--;
-    if (cond->waiters == 0 && r == WAIT_OBJECT_0 + 1)
-        ResetEvent(cond->events[1]);
-    if (r==WAIT_TIMEOUT) r = ETIMEDOUT;
-    else                 r = 0;
-    return r;
-}
-
-int 
-toku_pthread_cond_broadcast(toku_pthread_cond_t *cond) {
-    if (cond->waiters > 0)
-        SetEvent(cond->events[1]);
-    return 0;
-}
-
-int 
-toku_pthread_cond_signal(toku_pthread_cond_t *cond) { 
-    if (cond->waiters > 0)
-        SetEvent(cond->events[0]);
-    return 0;
-}
 
 int
 toku_pthread_yield(void) {

windows/toku_pthread.h

@@ -5,107 +5,140 @@
 extern "C" {
 #endif
 
+#include "pthread.h"
 #include <toku_time.h>
-#include <windows.h>
 
-#if defined(ETIMEDOUT)
-#error
-#endif
-#define ETIMEDOUT (WAIT_TIMEOUT)
-
-// pthread types
-
-typedef struct toku_pthread_attr {
-    SIZE_T stacksize;
-} toku_pthread_attr_t;
-
-typedef struct toku_pthread {
-    HANDLE handle;
-    DWORD id;
-    void *(*f)(void *);
-    void *arg;
-    void *ret;
-} *toku_pthread_t;
-
-typedef struct toku_pthread_rwlockattr *toku_pthread_rwlockattr_t;
-
-typedef struct toku_pthread_mutexattr *toku_pthread_mutexattr_t;
-
-typedef struct toku_pthread_mutex {
-    CRITICAL_SECTION section;
-    BOOL initialized;
-} toku_pthread_mutex_t;
-
-typedef struct toku_pthread_rwlock toku_pthread_rwlock_t;
-
-#define TOKU_PTHREAD_MUTEX_INITIALIZER { 0, 0 }
-
-typedef struct toku_pthread_condattr *toku_pthread_condattr_t;
-
-// WINNT >= 6 supports condition variables.  For now, we use a couple of events.
-#define TOKU_PTHREAD_COND_NEVENTS 2
-
-typedef struct toku_pthread_cond {
-#if 0
-    CONDITION_VARIABLE wcv;
-#else
-    HANDLE events[TOKU_PTHREAD_COND_NEVENTS];
-    int waiters;
-#endif
-} toku_pthread_cond_t;
-
-// pthread interface
+typedef pthread_attr_t toku_pthread_attr_t;
+typedef pthread_t toku_pthread_t;
+typedef pthread_mutexattr_t toku_pthread_mutexattr_t;
+typedef pthread_mutex_t toku_pthread_mutex_t;
+typedef pthread_condattr_t toku_pthread_condattr_t;
+typedef pthread_cond_t toku_pthread_cond_t;
+typedef pthread_rwlock_t toku_pthread_rwlock_t;
+typedef pthread_rwlockattr_t  toku_pthread_rwlockattr_t;
+//typedef struct timespec toku_timespec_t; //Already defined in toku_time.h
+
+static inline int
+toku_pthread_rwlock_init(toku_pthread_rwlock_t *__restrict rwlock, const toku_pthread_rwlockattr_t *__restrict attr) {
+    return pthread_rwlock_init(rwlock, attr);
+}
+
+static inline int
+toku_pthread_rwlock_destroy(toku_pthread_rwlock_t *rwlock) {
+    return pthread_rwlock_destroy(rwlock);
+}
+
+static inline int
+toku_pthread_rwlock_rdlock(toku_pthread_rwlock_t *rwlock) {
+    return pthread_rwlock_rdlock(rwlock);
+}
+
+static inline int
+toku_pthread_rwlock_rdunlock(toku_pthread_rwlock_t *rwlock) {
+    return pthread_rwlock_unlock(rwlock);
+}
+
+static inline int
+toku_pthread_rwlock_wrlock(toku_pthread_rwlock_t *rwlock) {
+    return pthread_rwlock_wrlock(rwlock);
+}
+
+static inline int
+toku_pthread_rwlock_wrunlock(toku_pthread_rwlock_t *rwlock) {
+    return pthread_rwlock_unlock(rwlock);
+}
 
 int toku_pthread_yield(void);
 
-int toku_pthread_attr_init(toku_pthread_attr_t *);
-int toku_pthread_attr_destroy(toku_pthread_attr_t *);
-int toku_pthread_attr_getstacksize(toku_pthread_attr_t *, size_t *stacksize);
-int toku_pthread_attr_setstacksize(toku_pthread_attr_t *, size_t stacksize);
-
-int toku_pthread_create(toku_pthread_t *thread, const toku_pthread_attr_t *attr, void *(*start_function)(void *), void *arg);
-
-int toku_pthread_join(toku_pthread_t thread, void **value_ptr);
-
-toku_pthread_t toku_pthread_self(void);
-
-
-int toku_pthread_mutex_init(toku_pthread_mutex_t *mutex, const toku_pthread_mutexattr_t *attr);
-
-int toku_pthread_mutex_destroy(toku_pthread_mutex_t *mutex);
-
-int toku_pthread_mutex_lock(toku_pthread_mutex_t *mutex);
+static inline
+int toku_pthread_attr_init(toku_pthread_attr_t *attr) {
+    return pthread_attr_init(attr);
+}
+
+static inline
+int toku_pthread_attr_destroy(toku_pthread_attr_t *attr) {
+    return pthread_attr_destroy(attr);
+}
+
+static inline
+int toku_pthread_attr_getstacksize(toku_pthread_attr_t *attr, size_t *stacksize) {
+    return pthread_attr_getstacksize(attr, stacksize);
+}
+
+static inline
+int toku_pthread_attr_setstacksize(toku_pthread_attr_t *attr, size_t stacksize) {
+    return pthread_attr_setstacksize(attr, stacksize);
+}
+
+static inline
+int toku_pthread_create(toku_pthread_t *thread, const toku_pthread_attr_t *attr, void *(*start_function)(void *), void *arg) {
+    return pthread_create(thread, attr, start_function, arg);
+}
+
+static inline
+int toku_pthread_join(toku_pthread_t thread, void **value_ptr) {
+    return pthread_join(thread, value_ptr);
+}
+
+static inline
+toku_pthread_t toku_pthread_self(void) {
+    return pthread_self();
+}
+
+#define TOKU_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+
+static inline
+int toku_pthread_mutex_init(toku_pthread_mutex_t *mutex, const toku_pthread_mutexattr_t *attr) {
+    return pthread_mutex_init(mutex, attr);
+}
+
+static inline
+int toku_pthread_mutex_destroy(toku_pthread_mutex_t *mutex) {
+    return pthread_mutex_destroy(mutex);
+}
+
+static inline
+int toku_pthread_mutex_lock(toku_pthread_mutex_t *mutex) {
+    return pthread_mutex_lock(mutex);
+}
 
 int toku_pthread_mutex_trylock(toku_pthread_mutex_t *mutex);
 
-int toku_pthread_mutex_unlock(toku_pthread_mutex_t *mutex);
-
-int toku_pthread_rwlock_init(toku_pthread_rwlock_t *restrict rwlock, const toku_pthread_rwlockattr_t *restrict attr);
-int toku_pthread_rwlock_destroy(toku_pthread_rwlock_t *rwlock);
-int toku_pthread_rwlock_rdlock(toku_pthread_rwlock_t *rwlock);
-int toku_pthread_rwlock_rdunlock(toku_pthread_rwlock_t *rwlock);
-int toku_pthread_rwlock_wrunlock(toku_pthread_rwlock_t *rwlock);
-int toku_pthread_rwlock_wrlock(toku_pthread_rwlock_t *rwlock);
+static inline
+int toku_pthread_mutex_unlock(toku_pthread_mutex_t *mutex) {
+    return pthread_mutex_unlock(mutex);
+}
+
+static inline
+int toku_pthread_cond_init(toku_pthread_cond_t *cond, const toku_pthread_condattr_t *attr) {
+    return pthread_cond_init(cond, attr);
+}
+
+static inline 
+int toku_pthread_cond_destroy(toku_pthread_cond_t *cond) {
+    return pthread_cond_destroy(cond);
+}
+
+static inline
+int toku_pthread_cond_wait(toku_pthread_cond_t *cond, toku_pthread_mutex_t *mutex) {
+    return pthread_cond_wait(cond, mutex);
+}
+
+static inline
+int toku_pthread_cond_timedwait(toku_pthread_cond_t *cond, toku_pthread_mutex_t *mutex, toku_timespec_t *wakeup_at) {
+    return pthread_cond_timedwait(cond, mutex, wakeup_at);
+}
+
+static inline
+int toku_pthread_cond_signal(toku_pthread_cond_t *cond) {
+    return pthread_cond_signal(cond);
+}
+
+static inline
+int toku_pthread_cond_broadcast(toku_pthread_cond_t *cond) {
+    return pthread_cond_broadcast(cond);
+}
 
-int toku_pthread_cond_init(toku_pthread_cond_t *cond, const toku_pthread_condattr_t *attr);
-
-int toku_pthread_cond_destroy(toku_pthread_cond_t *cond);
-
-int toku_pthread_cond_wait(toku_pthread_cond_t *cond, toku_pthread_mutex_t *mutex);
-
-int toku_pthread_cond_timedwait(toku_pthread_cond_t *cond, toku_pthread_mutex_t *mutex, toku_timespec_t *wakeup_at);
-
-int toku_pthread_cond_signal(toku_pthread_cond_t *cond);
-
-int toku_pthread_cond_broadcast(toku_pthread_cond_t *cond);
-
-#include <toku_assert.h>
-#include "../newbrt/rwlock.h"
-struct toku_pthread_rwlock {
-    struct rwlock        rwlock;
-    toku_pthread_mutex_t mutex;
-    BOOL                 initialized;
-};
 
 
 #if defined(__cplusplus)

windows/windows.c

@@ -4,8 +4,8 @@
 #define _CRT_RAND_S
 #include <stdlib.h>
 
+#include <toku_portability.h>
 #include <windows.h>
-#include "toku_portability.h"
 #include <dirent.h>
 #include <assert.h>
 #include <direct.h>