first cut at multithreading. works on Linux.

* kick off new os procs (machs) as needed
* add sys·sleep for testing
* add Lock, Rendez
* properly lock mal, sys·newproc, scheduler
* linux syscall arg #4 is in R10, not CX
* chans are not multithread-safe yet
* multithreading disabled by default;
  set $gomaxprocs=2 (or 1000) to turn it on

This should build on OS X but may not.
Rob and I will fix soon after submitting.

TBR=r
OCL=13784
CL=13842

diff --git a/src/cmd/gc/sys.go b/src/cmd/gc/sys.go
index 8c52d9e154a6480918d4449cde8f47618b33f53f..02137bf16e451bfa9523d463a2cbeda6e69147bd 100644 (file)
--- a/src/cmd/gc/sys.go
+++ b/src/cmd/gc/sys.go
@@ -64,6 +64,7 @@ func  writefile(string, string) (bool);       // write string into file; boolean status
 func   bytestorune(*byte, int32, int32) (int32, int32);        // convert bytes to runes       
 func   stringtorune(string, int32, int32) (int32, int32);      // convert bytes to runes       
 
+func   sleep(ms int64);
 func   exit(int32);
 
 export
@@ -136,5 +137,6 @@ export
        stringtorune
 
        // system calls
+       sleep
        exit
        ;

diff --git a/src/cmd/gc/sysimport.c b/src/cmd/gc/sysimport.c
index b586559fac8ddde847c4c333cffa538480ce6a4e..bf2b468ad433af0fca43df01da2c06bed48296bc 100644 (file)
--- a/src/cmd/gc/sysimport.c
+++ b/src/cmd/gc/sysimport.c
@@ -3,10 +3,10 @@ char* sysimport =
        "type sys._esys_002 {}\n"
        "type sys.any 24\n"
        "type sys._esys_003 *sys.any\n"
-       "type sys._osys_372 {_esys_370 sys._esys_003}\n"
+       "type sys._osys_373 {_esys_371 sys._esys_003}\n"
        "type sys.uint32 6\n"
-       "type sys._isys_374 {_esys_371 sys.uint32}\n"
-       "type sys._esys_001 (sys._esys_002 sys._osys_372 sys._isys_374)\n"
+       "type sys._isys_375 {_esys_372 sys.uint32}\n"
+       "type sys._esys_001 (sys._esys_002 sys._osys_373 sys._isys_375)\n"
        "var !sys.mal sys._esys_001\n"
        "type sys._esys_005 {}\n"
        "type sys._esys_006 {}\n"
@@ -16,243 +16,243 @@ char*     sysimport =
        "type sys._esys_009 {}\n"
        "type sys._esys_010 {}\n"
        "type sys.int32 5\n"
-       "type sys._isys_380 {_esys_379 sys.int32}\n"
-       "type sys._esys_008 (sys._esys_009 sys._esys_010 sys._isys_380)\n"
+       "type sys._isys_381 {_esys_380 sys.int32}\n"
+       "type sys._esys_008 (sys._esys_009 sys._esys_010 sys._isys_381)\n"
        "var !sys.panicl sys._esys_008\n"
        "type sys._esys_012 {}\n"
        "type sys._esys_013 {}\n"
        "type sys.bool 12\n"
-       "type sys._isys_385 {_esys_384 sys.bool}\n"
-       "type sys._esys_011 (sys._esys_012 sys._esys_013 sys._isys_385)\n"
+       "type sys._isys_386 {_esys_385 sys.bool}\n"
+       "type sys._esys_011 (sys._esys_012 sys._esys_013 sys._isys_386)\n"
        "var !sys.printbool sys._esys_011\n"
        "type sys._esys_015 {}\n"
        "type sys._esys_016 {}\n"
        "type sys.float64 10\n"
-       "type sys._isys_390 {_esys_389 sys.float64}\n"
-       "type sys._esys_014 (sys._esys_015 sys._esys_016 sys._isys_390)\n"
+       "type sys._isys_391 {_esys_390 sys.float64}\n"
+       "type sys._esys_014 (sys._esys_015 sys._esys_016 sys._isys_391)\n"
        "var !sys.printfloat sys._esys_014\n"
        "type sys._esys_018 {}\n"
        "type sys._esys_019 {}\n"
        "type sys.int64 7\n"
-       "type sys._isys_395 {_esys_394 sys.int64}\n"
-       "type sys._esys_017 (sys._esys_018 sys._esys_019 sys._isys_395)\n"
+       "type sys._isys_396 {_esys_395 sys.int64}\n"
+       "type sys._esys_017 (sys._esys_018 sys._esys_019 sys._isys_396)\n"
        "var !sys.printint sys._esys_017\n"
        "type sys._esys_021 {}\n"
        "type sys._esys_022 {}\n"
        "type sys._esys_023 25\n"
        "type sys.string *sys._esys_023\n"
-       "type sys._isys_400 {_esys_399 sys.string}\n"
-       "type sys._esys_020 (sys._esys_021 sys._esys_022 sys._isys_400)\n"
+       "type sys._isys_401 {_esys_400 sys.string}\n"
+       "type sys._esys_020 (sys._esys_021 sys._esys_022 sys._isys_401)\n"
        "var !sys.printstring sys._esys_020\n"
        "type sys._esys_025 {}\n"
        "type sys._esys_026 {}\n"
        "type sys._esys_027 *sys.any\n"
-       "type sys._isys_405 {_esys_404 sys._esys_027}\n"
-       "type sys._esys_024 (sys._esys_025 sys._esys_026 sys._isys_405)\n"
+       "type sys._isys_406 {_esys_405 sys._esys_027}\n"
+       "type sys._esys_024 (sys._esys_025 sys._esys_026 sys._isys_406)\n"
        "var !sys.printpointer sys._esys_024\n"
        "type sys._esys_029 {}\n"
-       "type sys._osys_412 {_esys_409 sys.string}\n"
-       "type sys._isys_414 {_esys_410 sys.string _esys_411 sys.string}\n"
-       "type sys._esys_028 (sys._esys_029 sys._osys_412 sys._isys_414)\n"
+       "type sys._osys_413 {_esys_410 sys.string}\n"
+       "type sys._isys_415 {_esys_411 sys.string _esys_412 sys.string}\n"
+       "type sys._esys_028 (sys._esys_029 sys._osys_413 sys._isys_415)\n"
        "var !sys.catstring sys._esys_028\n"
        "type sys._esys_031 {}\n"
-       "type sys._osys_422 {_esys_419 sys.int32}\n"
-       "type sys._isys_424 {_esys_420 sys.string _esys_421 sys.string}\n"
-       "type sys._esys_030 (sys._esys_031 sys._osys_422 sys._isys_424)\n"
+       "type sys._osys_423 {_esys_420 sys.int32}\n"
+       "type sys._isys_425 {_esys_421 sys.string _esys_422 sys.string}\n"
+       "type sys._esys_030 (sys._esys_031 sys._osys_423 sys._isys_425)\n"
        "var !sys.cmpstring sys._esys_030\n"
        "type sys._esys_033 {}\n"
-       "type sys._osys_433 {_esys_429 sys.string}\n"
-       "type sys._isys_435 {_esys_430 sys.string _esys_431 sys.int32 _esys_432 sys.int32}\n"
-       "type sys._esys_032 (sys._esys_033 sys._osys_433 sys._isys_435)\n"
+       "type sys._osys_434 {_esys_430 sys.string}\n"
+       "type sys._isys_436 {_esys_431 sys.string _esys_432 sys.int32 _esys_433 sys.int32}\n"
+       "type sys._esys_032 (sys._esys_033 sys._osys_434 sys._isys_436)\n"
        "var !sys.slicestring sys._esys_032\n"
        "type sys._esys_035 {}\n"
        "type sys.uint8 2\n"
-       "type sys._osys_444 {_esys_441 sys.uint8}\n"
-       "type sys._isys_446 {_esys_442 sys.string _esys_443 sys.int32}\n"
-       "type sys._esys_034 (sys._esys_035 sys._osys_444 sys._isys_446)\n"
+       "type sys._osys_445 {_esys_442 sys.uint8}\n"
+       "type sys._isys_447 {_esys_443 sys.string _esys_444 sys.int32}\n"
+       "type sys._esys_034 (sys._esys_035 sys._osys_445 sys._isys_447)\n"
        "var !sys.indexstring sys._esys_034\n"
        "type sys._esys_037 {}\n"
-       "type sys._osys_453 {_esys_451 sys.string}\n"
-       "type sys._isys_455 {_esys_452 sys.int64}\n"
-       "type sys._esys_036 (sys._esys_037 sys._osys_453 sys._isys_455)\n"
+       "type sys._osys_454 {_esys_452 sys.string}\n"
+       "type sys._isys_456 {_esys_453 sys.int64}\n"
+       "type sys._esys_036 (sys._esys_037 sys._osys_454 sys._isys_456)\n"
        "var !sys.intstring sys._esys_036\n"
        "type sys._esys_039 {}\n"
-       "type sys._osys_462 {_esys_459 sys.string}\n"
+       "type sys._osys_463 {_esys_460 sys.string}\n"
        "type sys._esys_040 *sys.uint8\n"
-       "type sys._isys_464 {_esys_460 sys._esys_040 _esys_461 sys.int32}\n"
-       "type sys._esys_038 (sys._esys_039 sys._osys_462 sys._isys_464)\n"
+       "type sys._isys_465 {_esys_461 sys._esys_040 _esys_462 sys.int32}\n"
+       "type sys._esys_038 (sys._esys_039 sys._osys_463 sys._isys_465)\n"
        "var !sys.byteastring sys._esys_038\n"
        "type sys._esys_042 {}\n"
        "type sys._esys_043 <>\n"
-       "type sys._osys_473 {_esys_469 sys._esys_043}\n"
+       "type sys._osys_474 {_esys_470 sys._esys_043}\n"
        "type sys._esys_044 *sys.uint8\n"
        "type sys._esys_045 *sys.uint8\n"
-       "type sys._ssys_480 {}\n"
-       "type sys._esys_046 *sys._ssys_480\n"
-       "type sys._isys_475 {_esys_470 sys._esys_044 _esys_471 sys._esys_045 _esys_472 sys._esys_046}\n"
-       "type sys._esys_041 (sys._esys_042 sys._osys_473 sys._isys_475)\n"
+       "type sys._ssys_481 {}\n"
+       "type sys._esys_046 *sys._ssys_481\n"
+       "type sys._isys_476 {_esys_471 sys._esys_044 _esys_472 sys._esys_045 _esys_473 sys._esys_046}\n"
+       "type sys._esys_041 (sys._esys_042 sys._osys_474 sys._isys_476)\n"
        "var !sys.mkiface sys._esys_041\n"
        "type sys._esys_048 {}\n"
-       "type sys._osys_484 {_esys_483 sys.int32}\n"
+       "type sys._osys_485 {_esys_484 sys.int32}\n"
        "type sys._esys_049 {}\n"
-       "type sys._esys_047 (sys._esys_048 sys._osys_484 sys._esys_049)\n"
+       "type sys._esys_047 (sys._esys_048 sys._osys_485 sys._esys_049)\n"
        "var !sys.argc sys._esys_047\n"
        "type sys._esys_051 {}\n"
-       "type sys._osys_488 {_esys_487 sys.int32}\n"
+       "type sys._osys_489 {_esys_488 sys.int32}\n"
        "type sys._esys_052 {}\n"
-       "type sys._esys_050 (sys._esys_051 sys._osys_488 sys._esys_052)\n"
+       "type sys._esys_050 (sys._esys_051 sys._osys_489 sys._esys_052)\n"
        "var !sys.envc sys._esys_050\n"
        "type sys._esys_054 {}\n"
-       "type sys._osys_493 {_esys_491 sys.string}\n"
-       "type sys._isys_495 {_esys_492 sys.int32}\n"
-       "type sys._esys_053 (sys._esys_054 sys._osys_493 sys._isys_495)\n"
+       "type sys._osys_494 {_esys_492 sys.string}\n"
+       "type sys._isys_496 {_esys_493 sys.int32}\n"
+       "type sys._esys_053 (sys._esys_054 sys._osys_494 sys._isys_496)\n"
        "var !sys.argv sys._esys_053\n"
        "type sys._esys_056 {}\n"
-       "type sys._osys_501 {_esys_499 sys.string}\n"
-       "type sys._isys_503 {_esys_500 sys.int32}\n"
-       "type sys._esys_055 (sys._esys_056 sys._osys_501 sys._isys_503)\n"
+       "type sys._osys_502 {_esys_500 sys.string}\n"
+       "type sys._isys_504 {_esys_501 sys.int32}\n"
+       "type sys._esys_055 (sys._esys_056 sys._osys_502 sys._isys_504)\n"
        "var !sys.envv sys._esys_055\n"
        "type sys._esys_058 {}\n"
-       "type sys._osys_510 {_esys_507 sys.float64 _esys_508 sys.int32}\n"
-       "type sys._isys_512 {_esys_509 sys.float64}\n"
-       "type sys._esys_057 (sys._esys_058 sys._osys_510 sys._isys_512)\n"
+       "type sys._osys_511 {_esys_508 sys.float64 _esys_509 sys.int32}\n"
+       "type sys._isys_513 {_esys_510 sys.float64}\n"
+       "type sys._esys_057 (sys._esys_058 sys._osys_511 sys._isys_513)\n"
        "var !sys.frexp sys._esys_057\n"
        "type sys._esys_060 {}\n"
-       "type sys._osys_519 {_esys_516 sys.float64}\n"
-       "type sys._isys_521 {_esys_517 sys.float64 _esys_518 sys.int32}\n"
-       "type sys._esys_059 (sys._esys_060 sys._osys_519 sys._isys_521)\n"
+       "type sys._osys_520 {_esys_517 sys.float64}\n"
+       "type sys._isys_522 {_esys_518 sys.float64 _esys_519 sys.int32}\n"
+       "type sys._esys_059 (sys._esys_060 sys._osys_520 sys._isys_522)\n"
        "var !sys.ldexp sys._esys_059\n"
        "type sys._esys_062 {}\n"
-       "type sys._osys_529 {_esys_526 sys.float64 _esys_527 sys.float64}\n"
-       "type sys._isys_531 {_esys_528 sys.float64}\n"
-       "type sys._esys_061 (sys._esys_062 sys._osys_529 sys._isys_531)\n"
+       "type sys._osys_530 {_esys_527 sys.float64 _esys_528 sys.float64}\n"
+       "type sys._isys_532 {_esys_529 sys.float64}\n"
+       "type sys._esys_061 (sys._esys_062 sys._osys_530 sys._isys_532)\n"
        "var !sys.modf sys._esys_061\n"
        "type sys._esys_064 {}\n"
-       "type sys._osys_538 {_esys_535 sys.bool}\n"
-       "type sys._isys_540 {_esys_536 sys.float64 _esys_537 sys.int32}\n"
-       "type sys._esys_063 (sys._esys_064 sys._osys_538 sys._isys_540)\n"
+       "type sys._osys_539 {_esys_536 sys.bool}\n"
+       "type sys._isys_541 {_esys_537 sys.float64 _esys_538 sys.int32}\n"
+       "type sys._esys_063 (sys._esys_064 sys._osys_539 sys._isys_541)\n"
        "var !sys.isInf sys._esys_063\n"
        "type sys._esys_066 {}\n"
-       "type sys._osys_547 {_esys_545 sys.bool}\n"
-       "type sys._isys_549 {_esys_546 sys.float64}\n"
-       "type sys._esys_065 (sys._esys_066 sys._osys_547 sys._isys_549)\n"
+       "type sys._osys_548 {_esys_546 sys.bool}\n"
+       "type sys._isys_550 {_esys_547 sys.float64}\n"
+       "type sys._esys_065 (sys._esys_066 sys._osys_548 sys._isys_550)\n"
        "var !sys.isNaN sys._esys_065\n"
        "type sys._esys_068 {}\n"
-       "type sys._osys_555 {_esys_553 sys.float64}\n"
-       "type sys._isys_557 {_esys_554 sys.int32}\n"
-       "type sys._esys_067 (sys._esys_068 sys._osys_555 sys._isys_557)\n"
+       "type sys._osys_556 {_esys_554 sys.float64}\n"
+       "type sys._isys_558 {_esys_555 sys.int32}\n"
+       "type sys._esys_067 (sys._esys_068 sys._osys_556 sys._isys_558)\n"
        "var !sys.Inf sys._esys_067\n"
        "type sys._esys_070 {}\n"
-       "type sys._osys_562 {_esys_561 sys.float64}\n"
+       "type sys._osys_563 {_esys_562 sys.float64}\n"
        "type sys._esys_071 {}\n"
-       "type sys._esys_069 (sys._esys_070 sys._osys_562 sys._esys_071)\n"
+       "type sys._esys_069 (sys._esys_070 sys._osys_563 sys._esys_071)\n"
        "var !sys.NaN sys._esys_069\n"
        "type sys._esys_073 {}\n"
        "type sys._esys_075 [sys.any] sys.any\n"
        "type sys._esys_074 *sys._esys_075\n"
-       "type sys._osys_565 {hmap sys._esys_074}\n"
-       "type sys._isys_567 {keysize sys.uint32 valsize sys.uint32 keyalg sys.uint32 valalg sys.uint32 hint sys.uint32}\n"
-       "type sys._esys_072 (sys._esys_073 sys._osys_565 sys._isys_567)\n"
+       "type sys._osys_566 {hmap sys._esys_074}\n"
+       "type sys._isys_568 {keysize sys.uint32 valsize sys.uint32 keyalg sys.uint32 valalg sys.uint32 hint sys.uint32}\n"
+       "type sys._esys_072 (sys._esys_073 sys._osys_566 sys._isys_568)\n"
        "var !sys.newmap sys._esys_072\n"
        "type sys._esys_077 {}\n"
-       "type sys._osys_576 {val sys.any}\n"
+       "type sys._osys_577 {val sys.any}\n"
        "type sys._esys_079 [sys.any] sys.any\n"
        "type sys._esys_078 *sys._esys_079\n"
-       "type sys._isys_578 {hmap sys._esys_078 key sys.any}\n"
-       "type sys._esys_076 (sys._esys_077 sys._osys_576 sys._isys_578)\n"
+       "type sys._isys_579 {hmap sys._esys_078 key sys.any}\n"
+       "type sys._esys_076 (sys._esys_077 sys._osys_577 sys._isys_579)\n"
        "var !sys.mapaccess1 sys._esys_076\n"
        "type sys._esys_081 {}\n"
-       "type sys._osys_584 {val sys.any pres sys.bool}\n"
+       "type sys._osys_585 {val sys.any pres sys.bool}\n"
        "type sys._esys_083 [sys.any] sys.any\n"
        "type sys._esys_082 *sys._esys_083\n"
-       "type sys._isys_586 {hmap sys._esys_082 key sys.any}\n"
-       "type sys._esys_080 (sys._esys_081 sys._osys_584 sys._isys_586)\n"
+       "type sys._isys_587 {hmap sys._esys_082 key sys.any}\n"
+       "type sys._esys_080 (sys._esys_081 sys._osys_585 sys._isys_587)\n"
        "var !sys.mapaccess2 sys._esys_080\n"
        "type sys._esys_085 {}\n"
        "type sys._esys_086 {}\n"
        "type sys._esys_088 [sys.any] sys.any\n"
        "type sys._esys_087 *sys._esys_088\n"
-       "type sys._isys_593 {hmap sys._esys_087 key sys.any val sys.any}\n"
-       "type sys._esys_084 (sys._esys_085 sys._esys_086 sys._isys_593)\n"
+       "type sys._isys_594 {hmap sys._esys_087 key sys.any val sys.any}\n"
+       "type sys._esys_084 (sys._esys_085 sys._esys_086 sys._isys_594)\n"
        "var !sys.mapassign1 sys._esys_084\n"
        "type sys._esys_090 {}\n"
        "type sys._esys_091 {}\n"
        "type sys._esys_093 [sys.any] sys.any\n"
        "type sys._esys_092 *sys._esys_093\n"
-       "type sys._isys_599 {hmap sys._esys_092 key sys.any val sys.any pres sys.bool}\n"
-       "type sys._esys_089 (sys._esys_090 sys._esys_091 sys._isys_599)\n"
+       "type sys._isys_600 {hmap sys._esys_092 key sys.any val sys.any pres sys.bool}\n"
+       "type sys._esys_089 (sys._esys_090 sys._esys_091 sys._isys_600)\n"
        "var !sys.mapassign2 sys._esys_089\n"
        "type sys._esys_095 {}\n"
        "type sys._esys_097 1 sys.any\n"
        "type sys._esys_096 *sys._esys_097\n"
-       "type sys._osys_606 {hchan sys._esys_096}\n"
-       "type sys._isys_608 {elemsize sys.uint32 elemalg sys.uint32 hint sys.uint32}\n"
-       "type sys._esys_094 (sys._esys_095 sys._osys_606 sys._isys_608)\n"
+       "type sys._osys_607 {hchan sys._esys_096}\n"
+       "type sys._isys_609 {elemsize sys.uint32 elemalg sys.uint32 hint sys.uint32}\n"
+       "type sys._esys_094 (sys._esys_095 sys._osys_607 sys._isys_609)\n"
        "var !sys.newchan sys._esys_094\n"
        "type sys._esys_099 {}\n"
-       "type sys._osys_615 {elem sys.any}\n"
+       "type sys._osys_616 {elem sys.any}\n"
        "type sys._esys_101 1 sys.any\n"
        "type sys._esys_100 *sys._esys_101\n"
-       "type sys._isys_617 {hchan sys._esys_100}\n"
-       "type sys._esys_098 (sys._esys_099 sys._osys_615 sys._isys_617)\n"
+       "type sys._isys_618 {hchan sys._esys_100}\n"
+       "type sys._esys_098 (sys._esys_099 sys._osys_616 sys._isys_618)\n"
        "var !sys.chanrecv1 sys._esys_098\n"
        "type sys._esys_103 {}\n"
-       "type sys._osys_622 {elem sys.any pres sys.bool}\n"
+       "type sys._osys_623 {elem sys.any pres sys.bool}\n"
        "type sys._esys_105 1 sys.any\n"
        "type sys._esys_104 *sys._esys_105\n"
-       "type sys._isys_624 {hchan sys._esys_104}\n"
-       "type sys._esys_102 (sys._esys_103 sys._osys_622 sys._isys_624)\n"
+       "type sys._isys_625 {hchan sys._esys_104}\n"
+       "type sys._esys_102 (sys._esys_103 sys._osys_623 sys._isys_625)\n"
        "var !sys.chanrecv2 sys._esys_102\n"
        "type sys._esys_107 {}\n"
-       "type sys._osys_630 {pres sys.bool}\n"
+       "type sys._osys_631 {pres sys.bool}\n"
        "type sys._esys_109 1 sys.any\n"
        "type sys._esys_108 *sys._esys_109\n"
        "type sys._esys_110 *sys.any\n"
-       "type sys._isys_632 {hchan sys._esys_108 elem sys._esys_110}\n"
-       "type sys._esys_106 (sys._esys_107 sys._osys_630 sys._isys_632)\n"
+       "type sys._isys_633 {hchan sys._esys_108 elem sys._esys_110}\n"
+       "type sys._esys_106 (sys._esys_107 sys._osys_631 sys._isys_633)\n"
        "var !sys.chanrecv3 sys._esys_106\n"
        "type sys._esys_112 {}\n"
        "type sys._esys_113 {}\n"
        "type sys._esys_115 1 sys.any\n"
        "type sys._esys_114 *sys._esys_115\n"
-       "type sys._isys_638 {hchan sys._esys_114 elem sys.any}\n"
-       "type sys._esys_111 (sys._esys_112 sys._esys_113 sys._isys_638)\n"
+       "type sys._isys_639 {hchan sys._esys_114 elem sys.any}\n"
+       "type sys._esys_111 (sys._esys_112 sys._esys_113 sys._isys_639)\n"
        "var !sys.chansend1 sys._esys_111\n"
        "type sys._esys_117 {}\n"
-       "type sys._osys_643 {pres sys.bool}\n"
+       "type sys._osys_644 {pres sys.bool}\n"
        "type sys._esys_119 1 sys.any\n"
        "type sys._esys_118 *sys._esys_119\n"
-       "type sys._isys_645 {hchan sys._esys_118 elem sys.any}\n"
-       "type sys._esys_116 (sys._esys_117 sys._osys_643 sys._isys_645)\n"
+       "type sys._isys_646 {hchan sys._esys_118 elem sys.any}\n"
+       "type sys._esys_116 (sys._esys_117 sys._osys_644 sys._isys_646)\n"
        "var !sys.chansend2 sys._esys_116\n"
        "type sys._esys_121 {}\n"
        "type sys._esys_122 *sys.uint8\n"
-       "type sys._osys_651 {sel sys._esys_122}\n"
-       "type sys._isys_653 {size sys.uint32}\n"
-       "type sys._esys_120 (sys._esys_121 sys._osys_651 sys._isys_653)\n"
+       "type sys._osys_652 {sel sys._esys_122}\n"
+       "type sys._isys_654 {size sys.uint32}\n"
+       "type sys._esys_120 (sys._esys_121 sys._osys_652 sys._isys_654)\n"
        "var !sys.newselect sys._esys_120\n"
        "type sys._esys_124 {}\n"
-       "type sys._osys_658 {selected sys.bool}\n"
+       "type sys._osys_659 {selected sys.bool}\n"
        "type sys._esys_125 *sys.uint8\n"
        "type sys._esys_127 1 sys.any\n"
        "type sys._esys_126 *sys._esys_127\n"
-       "type sys._isys_660 {sel sys._esys_125 hchan sys._esys_126 elem sys.any}\n"
-       "type sys._esys_123 (sys._esys_124 sys._osys_658 sys._isys_660)\n"
+       "type sys._isys_661 {sel sys._esys_125 hchan sys._esys_126 elem sys.any}\n"
+       "type sys._esys_123 (sys._esys_124 sys._osys_659 sys._isys_661)\n"
        "var !sys.selectsend sys._esys_123\n"
        "type sys._esys_129 {}\n"
-       "type sys._osys_667 {selected sys.bool}\n"
+       "type sys._osys_668 {selected sys.bool}\n"
        "type sys._esys_130 *sys.uint8\n"
        "type sys._esys_132 1 sys.any\n"
        "type sys._esys_131 *sys._esys_132\n"
        "type sys._esys_133 *sys.any\n"
-       "type sys._isys_669 {sel sys._esys_130 hchan sys._esys_131 elem sys._esys_133}\n"
-       "type sys._esys_128 (sys._esys_129 sys._osys_667 sys._isys_669)\n"
+       "type sys._isys_670 {sel sys._esys_130 hchan sys._esys_131 elem sys._esys_133}\n"
+       "type sys._esys_128 (sys._esys_129 sys._osys_668 sys._isys_670)\n"
        "var !sys.selectrecv sys._esys_128\n"
        "type sys._esys_135 {}\n"
        "type sys._esys_136 {}\n"
        "type sys._esys_137 *sys.uint8\n"
-       "type sys._isys_676 {sel sys._esys_137}\n"
-       "type sys._esys_134 (sys._esys_135 sys._esys_136 sys._isys_676)\n"
+       "type sys._isys_677 {sel sys._esys_137}\n"
+       "type sys._esys_134 (sys._esys_135 sys._esys_136 sys._isys_677)\n"
        "var !sys.selectgo sys._esys_134\n"
        "type sys._esys_139 {}\n"
        "type sys._esys_140 {}\n"
@@ -265,34 +265,39 @@ char*     sysimport =
        "type sys._esys_142 (sys._esys_143 sys._esys_144 sys._esys_145)\n"
        "var !sys.goexit sys._esys_142\n"
        "type sys._esys_147 {}\n"
-       "type sys._osys_685 {_esys_682 sys.string _esys_683 sys.bool}\n"
-       "type sys._isys_687 {_esys_684 sys.string}\n"
-       "type sys._esys_146 (sys._esys_147 sys._osys_685 sys._isys_687)\n"
+       "type sys._osys_686 {_esys_683 sys.string _esys_684 sys.bool}\n"
+       "type sys._isys_688 {_esys_685 sys.string}\n"
+       "type sys._esys_146 (sys._esys_147 sys._osys_686 sys._isys_688)\n"
        "var !sys.readfile sys._esys_146\n"
        "type sys._esys_149 {}\n"
-       "type sys._osys_694 {_esys_691 sys.bool}\n"
-       "type sys._isys_696 {_esys_692 sys.string _esys_693 sys.string}\n"
-       "type sys._esys_148 (sys._esys_149 sys._osys_694 sys._isys_696)\n"
+       "type sys._osys_695 {_esys_692 sys.bool}\n"
+       "type sys._isys_697 {_esys_693 sys.string _esys_694 sys.string}\n"
+       "type sys._esys_148 (sys._esys_149 sys._osys_695 sys._isys_697)\n"
        "var !sys.writefile sys._esys_148\n"
        "type sys._esys_151 {}\n"
-       "type sys._osys_706 {_esys_701 sys.int32 _esys_702 sys.int32}\n"
+       "type sys._osys_707 {_esys_702 sys.int32 _esys_703 sys.int32}\n"
        "type sys._esys_152 *sys.uint8\n"
-       "type sys._isys_708 {_esys_703 sys._esys_152 _esys_704 sys.int32 _esys_705 sys.int32}\n"
-       "type sys._esys_150 (sys._esys_151 sys._osys_706 sys._isys_708)\n"
+       "type sys._isys_709 {_esys_704 sys._esys_152 _esys_705 sys.int32 _esys_706 sys.int32}\n"
+       "type sys._esys_150 (sys._esys_151 sys._osys_707 sys._isys_709)\n"
        "var !sys.bytestorune sys._esys_150\n"
        "type sys._esys_154 {}\n"
-       "type sys._osys_719 {_esys_714 sys.int32 _esys_715 sys.int32}\n"
-       "type sys._isys_721 {_esys_716 sys.string _esys_717 sys.int32 _esys_718 sys.int32}\n"
-       "type sys._esys_153 (sys._esys_154 sys._osys_719 sys._isys_721)\n"
+       "type sys._osys_720 {_esys_715 sys.int32 _esys_716 sys.int32}\n"
+       "type sys._isys_722 {_esys_717 sys.string _esys_718 sys.int32 _esys_719 sys.int32}\n"
+       "type sys._esys_153 (sys._esys_154 sys._osys_720 sys._isys_722)\n"
        "var !sys.stringtorune sys._esys_153\n"
        "type sys._esys_156 {}\n"
        "type sys._esys_157 {}\n"
-       "type sys._isys_728 {_esys_727 sys.int32}\n"
+       "type sys._isys_728 {ms sys.int64}\n"
        "type sys._esys_155 (sys._esys_156 sys._esys_157 sys._isys_728)\n"
-       "var !sys.exit sys._esys_155\n"
+       "var !sys.sleep sys._esys_155\n"
        "type sys._esys_159 {}\n"
        "type sys._esys_160 {}\n"
-       "type sys._esys_161 {}\n"
-       "type sys._esys_158 (sys._esys_159 sys._esys_160 sys._esys_161)\n"
+       "type sys._isys_733 {_esys_732 sys.int32}\n"
+       "type sys._esys_158 (sys._esys_159 sys._esys_160 sys._isys_733)\n"
+       "var !sys.exit sys._esys_158\n"
+       "type sys._esys_162 {}\n"
+       "type sys._esys_163 {}\n"
+       "type sys._esys_164 {}\n"
+       "type sys._esys_161 (sys._esys_162 sys._esys_163 sys._esys_164)\n"
        "))\n"
 ;

diff --git a/src/runtime/amd64_linux.h b/src/runtime/amd64_linux.h
index 9412954b4c80aeb4792a5634c090a712ec8f0dca..6a166425a8a9cd9be03da538c78d548686bd8002 100644 (file)
--- a/src/runtime/amd64_linux.h
+++ b/src/runtime/amd64_linux.h
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 /*
- *  System structs for Darwin, amd64
+ *  System structs for Linux, amd64
  */
 
 typedef uint64 dev_t;
@@ -22,6 +22,11 @@ struct timespec {
        int64 tv_nsec;
 };
 
+struct timeval {
+       time_t tv_sec;
+       int64 tv_usec;
+};
+
 struct stat {
        dev_t   st_dev;     /* ID of device containing file */
        ino_t   st_ino;     /* inode number */
@@ -40,3 +45,9 @@ struct stat {
 };
 
 #define        O_CREAT 0100
+
+// Linux-specific system calls
+int64  futex(uint32*, int32, uint32, struct timespec*, uint32*, uint32);
+int64  clone(int32, void*, M*, G*, void(*)(void*), void*);
+int64  select(int32, void*, void*, void*, void*);
+

diff --git a/src/runtime/chan.c b/src/runtime/chan.c
index 9796e6c091f13b524eb65c9bf21ec4927f5b7567..963e69944562c996daa677c99ecd1c7eb67ea28d 100644 (file)
--- a/src/runtime/chan.c
+++ b/src/runtime/chan.c
@@ -4,6 +4,8 @@
 
 #include "runtime.h"
 
+// TODO locking of select
+
 static int32   debug   = 0;
 
 typedef        struct  Hchan   Hchan;
@@ -30,6 +32,7 @@ struct        WaitQ
 
 struct Hchan
 {
+       Lock;
        uint32  elemsize;
        uint32  dataqsiz;               // size of the circular q
        uint32  qcount;                 // total data in the q
@@ -159,6 +162,7 @@ sendchan(Hchan *c, byte *ep, bool *pres)
                prints("\n");
        }
 
+       lock(c);
        if(c->dataqsiz > 0)
                goto asynch;
 
@@ -169,7 +173,8 @@ sendchan(Hchan *c, byte *ep, bool *pres)
 
                gp = sg->g;
                gp->param = sg;
-               gp->status = Grunnable;
+               unlock(c);
+               ready(gp);
 
                if(pres != nil)
                        *pres = true;
@@ -177,6 +182,7 @@ sendchan(Hchan *c, byte *ep, bool *pres)
        }
 
        if(pres != nil) {
+               unlock(c);
                *pres = false;
                return;
        }
@@ -187,18 +193,24 @@ sendchan(Hchan *c, byte *ep, bool *pres)
        g->param = nil;
        g->status = Gwaiting;
        enqueue(&c->sendq, sg);
+       unlock(c);
        sys·gosched();
 
+       lock(c);
        sg = g->param;
        freesg(c, sg);
+       unlock(c);
        return;
 
 asynch:
        while(c->qcount >= c->dataqsiz) {
+               // (rsc) should check for pres != nil
                sg = allocsg(c);
                g->status = Gwaiting;
                enqueue(&c->sendq, sg);
+               unlock(c);
                sys·gosched();
+               lock(c);
        }
        if(ep != nil)
                c->elemalg->copy(c->elemsize, c->senddataq->elem, ep);
@@ -209,8 +221,10 @@ asynch:
        if(sg != nil) {
                gp = sg->g;
                freesg(c, sg);
-               gp->status = Grunnable;
-       }
+               unlock(c);
+               ready(gp);
+       }else
+               unlock(c);
 }
 
 static void
@@ -225,6 +239,7 @@ chanrecv(Hchan* c, byte *ep, bool* pres)
                prints("\n");
        }
 
+       lock(c);
        if(c->dataqsiz > 0)
                goto asynch;
 
@@ -234,7 +249,8 @@ chanrecv(Hchan* c, byte *ep, bool* pres)
 
                gp = sg->g;
                gp->param = sg;
-               gp->status = Grunnable;
+               unlock(c);
+               ready(gp);
 
                if(pres != nil)
                        *pres = true;
@@ -242,6 +258,7 @@ chanrecv(Hchan* c, byte *ep, bool* pres)
        }
 
        if(pres != nil) {
+               unlock(c);
                *pres = false;
                return;
        }
@@ -250,11 +267,14 @@ chanrecv(Hchan* c, byte *ep, bool* pres)
        g->param = nil;
        g->status = Gwaiting;
        enqueue(&c->recvq, sg);
+       unlock(c);
        sys·gosched();
 
+       lock(c);
        sg = g->param;
        c->elemalg->copy(c->elemsize, ep, sg->elem);
        freesg(c, sg);
+       unlock(c);
        return;
 
 asynch:
@@ -262,7 +282,9 @@ asynch:
                sg = allocsg(c);
                g->status = Gwaiting;
                enqueue(&c->recvq, sg);
+               unlock(c);
                sys·gosched();
+               lock(c);
        }
        c->elemalg->copy(c->elemsize, ep, c->recvdataq->elem);
        c->recvdataq = c->recvdataq->link;
@@ -271,8 +293,10 @@ asynch:
        if(sg != nil) {
                gp = sg->g;
                freesg(c, sg);
-               gp->status = Grunnable;
-       }
+               unlock(c);
+               ready(gp);
+       }else
+               unlock(c);
 }
 
 // chansend1(hchan *chan any, elem any);
@@ -571,6 +595,8 @@ sys·selectgo(Select *sel)
        }
 
        // send and recv paths to sleep for a rendezvous
+       // (rsc) not correct to set Gwaiting after queueing;
+       // might already have been readied.
        g->status = Gwaiting;
        sys·gosched();
 
@@ -619,7 +645,7 @@ gotr:
                c->elemalg->copy(c->elemsize, cas->u.elemp, sg->elem);
        gp = sg->g;
        gp->param = sg;
-       gp->status = Grunnable;
+       ready(gp);
        goto retc;
 
 gots:
@@ -636,7 +662,7 @@ gots:
        c->elemalg->copy(c->elemsize, sg->elem, cas->u.elem);
        gp = sg->g;
        gp->param = sg;
-       gp->status = Grunnable;
+       ready(gp);
 
 retc:
        if(sel->ncase >= 1 && sel->ncase < nelem(selfree)) {

diff --git a/src/runtime/proc.c b/src/runtime/proc.c
index 232ee1b03c616e5052a236fa7bb790dcf257aac8..ef86a9a44927c46c7a6dbbdd66ddaa9c8637aa6b 100644 (file)
--- a/src/runtime/proc.c
+++ b/src/runtime/proc.c
@@ -4,18 +4,58 @@
 
 #include "runtime.h"
 
+typedef struct Sched Sched;
+
+M      m0;
+G      g0;     // idle goroutine for m0
+
+// Maximum number of os procs (M's) to kick off.
+// Can override with $gomaxprocs environment variable.
+// For now set to 1 (single-threaded), because not 
+// everything is properly locked (e.g., chans) and because
+// Darwin's multithreading code isn't implemented.
+int32  gomaxprocs = 1;
+
 static int32   debug   = 0;
 
+struct Sched {
+       G *runhead;
+       G *runtail;
+       int32 nwait;
+       int32 nready;
+       int32 ng;
+       int32 nm;
+       M *wait;
+       Lock;
+};
+
+Sched sched;
+
 void
 sys·goexit(void)
 {
-//prints("goexit goid=");
-//sys·printint(g->goid);
-//prints("\n");
+       if(debug){
+               prints("goexit goid=");
+               sys·printint(g->goid);
+               prints("\n");
+       }
        g->status = Gdead;
        sys·gosched();
 }
 
+void
+schedinit(void)
+{
+       byte *p;
+       extern int32 getenvc(void);
+       
+       p = getenv("gomaxprocs");
+       if(p && '0' <= *p && *p <= '9')
+               gomaxprocs = atoi(p);
+       sched.nm = 1;
+       sched.nwait = 1;
+}
+
 void
 sys·newproc(int32 siz, byte* fn, byte* arg0)
 {
@@ -64,10 +104,13 @@ sys·newproc(int32 siz, byte* fn, byte* arg0)
        newg->sched.SP = sp;
        newg->sched.PC = fn;
 
+       lock(&sched);
+       sched.ng++;
        goidgen++;
        newg->goid = goidgen;
+       unlock(&sched);
 
-       newg->status = Grunnable;
+       ready(newg);
 
 //prints(" goid=");
 //sys·printint(newg->goid);
@@ -80,7 +123,7 @@ tracebackothers(G *me)
        G *g;
 
        for(g = allg; g != nil; g = g->alllink) {
-               if(g == me)
+               if(g == me || g->status == Gdead)
                        continue;
                prints("\ngoroutine ");
                sys·printint(g->goid);
@@ -89,46 +132,175 @@ tracebackothers(G *me)
        }
 }
 
+void newmach(void);
+
+static void
+readylocked(G *g)
+{
+       g->status = Grunnable;
+       if(sched.runhead == nil)
+               sched.runhead = g;
+       else
+               sched.runtail->runlink = g;
+       sched.runtail = g;
+       g->runlink = nil;
+       sched.nready++;
+       // Don't wake up another scheduler.
+       // This only gets called when we're
+       // about to reschedule anyway.
+}
+
+static Lock print;
+       
+void
+ready(G *g)
+{
+       M *mm;
+
+       // gp might be running on another scheduler.
+       // (E.g., it queued and then we decided to wake it up
+       // before it had a chance to sys·gosched().)
+       // Grabbing the runlock ensures that it is not running elsewhere.
+       // You can delete the if check, but don't delete the 
+       // lock/unlock sequence (being able to grab the lock
+       // means the proc has gone to sleep).
+       lock(&g->runlock);
+       if(g->status == Grunnable || g->status == Grunning)
+               *(int32*)0x1023 = 0x1023;
+       lock(&sched);
+       g->status = Grunnable;
+       if(sched.runhead == nil)
+               sched.runhead = g;
+       else
+               sched.runtail->runlink = g;
+       sched.runtail = g;
+       g->runlink = nil;
+       unlock(&g->runlock);
+       sched.nready++;
+       if(sched.nready > sched.nwait)
+       if(gomaxprocs == 0 || sched.nm < gomaxprocs){
+               if(debug){
+                       prints("new scheduler: ");
+                       sys·printint(sched.nready);
+                       prints(" > ");
+                       sys·printint(sched.nwait);
+                       prints("\n");
+               }
+               sched.nwait++;
+               newmach();
+       }
+       if(sched.wait){
+               mm = sched.wait;
+               sched.wait = mm->waitlink;
+               rwakeupandunlock(&mm->waitr);
+       }else
+               unlock(&sched);
+}
+
+extern void p0(void), p1(void);
+
 G*
 nextgoroutine(void)
 {
        G *gp;
 
-       gp = m->lastg;
-       if(gp == nil)
-               gp = allg;
-
-       for(gp=gp->alllink; gp!=nil; gp=gp->alllink) {
-               if(gp->status == Grunnable) {
-                       m->lastg = gp;
-                       return gp;
+       while((gp = sched.runhead) == nil){
+               if(debug){
+                       prints("nextgoroutine runhead=nil ng=");
+                       sys·printint(sched.ng);
+                       prints("\n");
                }
+               if(sched.ng == 0)
+                       return nil;
+               m->waitlink = sched.wait;
+               m->waitr.l = &sched.Lock;
+               sched.wait = m;
+               sched.nwait++;
+               if(sched.nm == sched.nwait)
+                       prints("all goroutines are asleep - deadlock!\n");
+               rsleep(&m->waitr);
+               sched.nwait--;
        }
-       for(gp=allg; gp!=nil; gp=gp->alllink) {
-               if(gp->status == Grunnable) {
-                       m->lastg = gp;
-                       return gp;
-               }
-       }
-       return nil;
+       sched.nready--;
+       sched.runhead = gp->runlink;
+       return gp;
 }
 
 void
 scheduler(void)
 {
        G* gp;
-       
+
+       m->pid = getprocid();
+
        gosave(&m->sched);
+       lock(&sched);
+
+       if(m->curg == nil){
+               // Brand new scheduler; nwait counts us.
+               // Not anymore.
+               sched.nwait--;
+       }else{
+               gp = m->curg;
+               gp->m = nil;
+               switch(gp->status){
+               case Gdead:
+                       sched.ng--;
+                       if(debug){
+                               prints("sched: dead: ");
+                               sys·printint(sched.ng);
+                               prints("\n");
+                       }
+                       break;
+               case Grunning:
+                       readylocked(gp);
+                       break;
+               case Grunnable:
+                       // don't want to see this
+                       *(int32*)0x456 = 0x234;
+                       break;
+               }
+               unlock(&gp->runlock);
+       }
+
        gp = nextgoroutine();
        if(gp == nil) {
 //             prints("sched: no more work\n");
                sys·exit(0);
        }
+       unlock(&sched);
+       
+       lock(&gp->runlock);
+       gp->status = Grunning;
        m->curg = gp;
+       gp->m = m;
        g = gp;
        gogo(&gp->sched);
 }
 
+void
+newmach(void)
+{
+       M *mm;
+       byte *stk, *stktop;
+       int64 ret;
+       
+       sched.nm++;
+       if(!(sched.nm&(sched.nm-1))){
+               sys·printint(sched.nm);
+               prints(" threads\n");
+       }
+       mm = mal(sizeof(M)+sizeof(G)+1024+104);
+       sys·memclr((byte*)mm, sizeof(M));
+       mm->g0 = (G*)(mm+1);
+       sys·memclr((byte*)mm->g0, sizeof(G));
+       stk = (byte*)mm->g0 + 104;
+       stktop = stk + 1024;
+       mm->g0->stackguard = stk;
+       mm->g0->stackbase = stktop;
+       newosproc(mm, mm->g0, stktop, (void(*)(void*))scheduler, nil);
+}
+
 void
 gom0init(void)
 {
@@ -138,10 +310,11 @@ gom0init(void)
 void
 sys·gosched(void)
 {
-       if(gosave(&g->sched))
-               return;
-       g = m->g0;
-       gogo(&m->sched);
+       if(gosave(&g->sched) == 0){
+               // (rsc) signal race here?
+               g = m->g0;
+               gogo(&m->sched);
+       }
 }
 
 //

diff --git a/src/runtime/rt0_amd64.s b/src/runtime/rt0_amd64.s
index 20761464fb73f4ca7e080f4db9789984981571da..9d7aedc7db32880524dd7357e4e6a02c33cadf11 100644 (file)
--- a/src/runtime/rt0_amd64.s
+++ b/src/runtime/rt0_amd64.s
@@ -14,9 +14,9 @@ TEXT  _rt0_amd64(SB),7,$-8
        MOVQ    AX, 16(SP)
        MOVQ    BX, 24(SP)
 
-       // allocate the per-user and per-mach blocks
+       // set the per-goroutine and per-mach registers
 
-       LEAQ    m0<>(SB), R14           // dedicated m. register
+       LEAQ    m0(SB), R14             // dedicated m. register
        LEAQ    g0(SB), R15             // dedicated g. register
        MOVQ    R15, 0(R14)             // m has pointer to its g0
 
@@ -33,8 +33,9 @@ TEXT  _rt0_amd64(SB),7,$-8
        MOVQ    24(SP), AX              // copy argv
        MOVQ    AX, 8(SP)
        CALL    args(SB)
+       CALL    schedinit(SB)
        CALL    main·init_function(SB) // initialization
-
+       
        // create a new goroutine to start program
 
        PUSHQ   $main·main(SB)         // entry
@@ -102,4 +103,22 @@ TEXT setspgoto(SB), 7, $0
        POPQ    AX
        RET
 
-GLOBL  m0<>(SB),$64
+// bool cas(int32 *val, int32 old, int32 new)
+// Atomically:
+//     if(*val == old){
+//             *val = new;
+//             return 1;
+//     }else
+//             return 0;
+TEXT cas(SB), 7, $0
+       MOVQ    8(SP), BX
+       MOVL    16(SP), AX
+       MOVL    20(SP), CX
+       LOCK
+       CMPXCHGL        CX, 0(BX)
+       JZ 3(PC)
+       MOVL    $0, AX
+       RET
+       MOVL    $1, AX
+       RET
+

diff --git a/src/runtime/rt1_amd64_darwin.c b/src/runtime/rt1_amd64_darwin.c
index e0d2cb8b776ae054858b7e5d7504ef393b7cf553..3878649e4bf8067a8e280a3392b894050ee94471 100644 (file)
--- a/src/runtime/rt1_amd64_darwin.c
+++ b/src/runtime/rt1_amd64_darwin.c
@@ -5,7 +5,6 @@
 #include "runtime.h"
 #include "signals.h"
 
-
 typedef uint64 __uint64_t;
 
 /* From /usr/include/mach/i386/_structs.h */
@@ -174,3 +173,75 @@ initsig(void)
                        sys·sigaction(i, &a, (void*)0);
                }
 }
+
+static void
+unimplemented(int8 *name)
+{
+       prints(name);
+       prints(" not implemented\n");
+       *(int32*)1231 = 1231;
+}
+
+void
+sys·sleep(int64 ms)
+{
+       unimplemented("sleep");
+}
+
+void
+lock(Lock *l)
+{
+       if(xadd(&l->key, 1) == 1)
+               return;
+       unimplemented("lock wait");
+}
+
+void
+unlock(Lock *l)
+{
+       if(xadd(&l->key, -1) == 0)
+               return;
+       unimplemented("unlock wakeup");
+}
+
+void
+rsleep(Rendez *r)
+{
+       unimplemented("rsleep");
+
+       // dumb implementation:
+       r->sleeping = 1;
+       unlock(r->l);
+       while(r->sleeping)
+               ;
+       lock(r->l);
+}
+
+void
+rwakeup(Rendez *r)
+{
+       unimplemented("rwakeup");
+
+       // dumb implementation:
+       r->sleeping = 0;
+}
+
+void
+rwakeupandunlock(Rendez *r)
+{
+       // dumb implementation:
+       rwakeup(r);
+       unlock(r->l);
+}
+
+void
+newosproc(M *mm, G *gg, void *stk, void (*fn)(void*), void *arg)
+{
+       unimplemented("newosproc");
+}
+
+int32
+getprocid(void)
+{
+       return 0;
+}

diff --git a/src/runtime/rt1_amd64_linux.c b/src/runtime/rt1_amd64_linux.c
index 99700fdf8980ffb69e2b7221901137bc7ec0560e..df0274f76a91d358b9754c06c4c76ba2cf2908e8 100644 (file)
--- a/src/runtime/rt1_amd64_linux.c
+++ b/src/runtime/rt1_amd64_linux.c
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
+#include "amd64_linux.h"
 #include "signals.h"
 
 /* From /usr/include/asm-x86_64/sigcontext.h */
@@ -161,7 +162,7 @@ sighandler(int32 sig, siginfo* info, void** context)
 }
 
 
-sigaction a;
+static sigaction a;
 
 void
 initsig(void)
@@ -177,3 +178,235 @@ initsig(void)
                        sys·rt_sigaction(i, &a, (void*)0, 8);
                }
 }
+
+// Linux futex.  The simple cases really are simple:
+//
+//     futex(addr, FUTEX_WAIT, val, duration, _, _)
+//             Inside the kernel, atomically check that *addr == val
+//             and go to sleep for at most duration.
+//
+//     futex(addr, FUTEX_WAKE, val, _, _, _)
+//             Wake up at least val procs sleeping on addr.
+//
+// (Of course, they have added more complicated things since then.)
+
+enum
+{      
+       FUTEX_WAIT = 0,
+       FUTEX_WAKE = 1,
+       
+       EINTR = 4,
+       EAGAIN = 11,
+};
+
+// TODO(rsc) I tried using 1<<40 here but it woke up (-ETIMEDOUT).
+// I wonder if the timespec that gets to the kernel
+// actually has two 32-bit numbers in it, so that
+// a 64-bit 1<<40 ends up being 0 seconds, 
+// 1<<8 nanoseconds.
+static struct timespec longtime =
+{
+       1<<30,  // 34 years
+       0
+};
+
+static void
+efutex(uint32 *addr, int32 op, int32 val, struct timespec *ts)
+{
+       int64 ret;
+
+again:
+       ret = futex(addr, op, val, ts, nil, 0);
+
+       // These happen when you use a debugger, among other times.
+       if(ret == -EAGAIN || ret == -EINTR){
+               // If we were sleeping, it's okay to wake up early.
+               if(op == FUTEX_WAIT)
+                       return;
+               
+               // If we were waking someone up, we don't know
+               // whether that succeeded, so wake someone else up too.
+               if(op == FUTEX_WAKE){
+prints("futexwake ");
+sys·printint(ret);
+prints("\n");
+                       goto again;
+               }
+       }
+
+       if(ret < 0){
+               prints("futex error addr=");
+               sys·printpointer(addr);
+               prints(" op=");
+               sys·printint(op);
+               prints(" val=");
+               sys·printint(val);
+               prints(" ts=");
+               sys·printpointer(ts);
+               prints(" returned ");
+               sys·printint(-ret);
+               prints("\n");
+               *(int32*)101 = 202;
+       }
+}
+
+// Lock and unlock.  
+// A zeroed Lock is unlocked (no need to initialize each lock).
+// The l->key is either 0 (unlocked), 1 (locked), or >=2 (contended).
+
+void
+lock(Lock *l)
+{
+       uint32 v;
+       
+       if(l->key != 0) *(int32*)0x1001 = 0x1001;
+       l->key = 1;
+       return;
+
+       for(;;){
+               // Try for lock.  If we incremented it from 0 to 1, we win.
+               if((v=xadd(&l->key, 1)) == 1)
+                       return;
+
+               // We lose.  It was already >=1 and is now >=2.
+               // Use futex to atomically check that the value is still
+               // what we think it is and go to sleep.
+               efutex(&l->key, FUTEX_WAIT, v, &longtime);
+       }
+}
+
+void
+unlock(Lock *l)
+{
+       uint32 v;
+
+       if(l->key != 1) *(int32*)0x1002 = 0x1002;
+       l->key = 0;
+       return;
+
+       // Unlock the lock.  If we decremented from 1 to 0, wasn't contended.
+       if((v=xadd(&l->key, -1)) == 0)
+               return;
+       
+       // The lock was contended.  Mark it as unlocked and wake a waiter.
+       l->key = 0;
+       efutex(&l->key, FUTEX_WAKE, 1, nil);
+}
+
+// Sleep and wakeup (see description in runtime.h)
+
+void
+rsleep(Rendez *r)
+{
+       // Record that we're about to go to sleep and drop the lock.
+       r->sleeping = 1;
+       unlock(r->l);
+       
+       // Go to sleep if r->sleeping is still 1.
+       efutex(&r->sleeping, FUTEX_WAIT, 1, &longtime);
+
+       // Reacquire the lock.
+       lock(r->l);
+}
+
+void
+rwakeup(Rendez *r)
+{
+       if(!r->sleeping)
+               return;
+
+       // Clear the sleeping flag in case sleeper
+       // is between unlock and futex.
+       r->sleeping = 0;
+       
+       // Wake up if actually made it to sleep.
+       efutex(&r->sleeping, FUTEX_WAKE, 1, nil);
+}
+
+// Like rwakeup(r), unlock(r->l), but drops the lock before
+// waking the other proc.  This reduces bouncing back and forth
+// in the scheduler: the first thing the other proc wants to do
+// is acquire r->l, so it helps to unlock it before we wake him.
+void
+rwakeupandunlock(Rendez *r)
+{
+       int32 wassleeping;
+       
+       if(!r->sleeping){
+               unlock(r->l);
+               return;
+       }
+
+       r->sleeping = 0;
+       unlock(r->l);
+       efutex(&r->sleeping, FUTEX_WAKE, 1, nil);
+}
+
+enum
+{
+       CLONE_VM = 0x100,
+       CLONE_FS = 0x200,
+       CLONE_FILES = 0x400,
+       CLONE_SIGHAND = 0x800,
+       CLONE_PTRACE = 0x2000,
+       CLONE_VFORK = 0x4000,
+       CLONE_PARENT = 0x8000,
+       CLONE_THREAD = 0x10000,
+       CLONE_NEWNS = 0x20000,
+       CLONE_SYSVSEM = 0x40000,
+       CLONE_SETTLS = 0x80000,
+       CLONE_PARENT_SETTID = 0x100000,
+       CLONE_CHILD_CLEARTID = 0x200000,
+       CLONE_UNTRACED = 0x800000,
+       CLONE_CHILD_SETTID = 0x1000000,
+       CLONE_STOPPED = 0x2000000,
+       CLONE_NEWUTS = 0x4000000,
+       CLONE_NEWIPC = 0x8000000,
+};
+
+void
+newosproc(M *mm, G *gg, void *stk, void (*fn)(void*), void *arg)
+{
+       int64 ret;
+       int32 flags;
+       
+       flags = CLONE_PARENT    /* getppid doesn't change in child */
+               | CLONE_VM      /* share memory */
+               | CLONE_FS      /* share cwd, etc */
+               | CLONE_FILES   /* share fd table */
+               | CLONE_SIGHAND /* share sig handler table */
+               | CLONE_PTRACE  /* revisit - okay for now */
+               | CLONE_THREAD  /* revisit - okay for now */
+               ;
+
+       if(0){
+               prints("newosproc stk=");
+               sys·printpointer(stk);
+               prints(" mm=");
+               sys·printpointer(mm);
+               prints(" gg=");
+               sys·printpointer(gg);
+               prints(" fn=");
+               sys·printpointer(fn);
+               prints(" arg=");
+               sys·printpointer(arg);
+               prints(" clone=");
+               sys·printpointer(clone);
+               prints("\n");
+       }
+
+       ret = clone(flags, stk, mm, gg, fn, arg);
+       if(ret < 0)
+               *(int32*)123 = 123;
+}
+
+void
+sys·sleep(int64 ms)
+{
+       struct timeval tv;
+
+       tv.tv_sec = ms/1000;
+       tv.tv_usec = ms%1000 * 1000;
+       select(0, nil, nil, nil, &tv);
+}
+

diff --git a/src/runtime/runtime.c b/src/runtime/runtime.c
index b53f857cb02e50316deaf2ccd549de0a93545d1d..75d23d50d8b5f017940465dd69d69cae83e42ede 100644 (file)
--- a/src/runtime/runtime.c
+++ b/src/runtime/runtime.c
@@ -4,7 +4,6 @@
 
 #include "runtime.h"
 
-G      g0;                     // idle goroutine
 int32  debug   = 0;
 
 void
@@ -24,10 +23,6 @@ sys·panicl(int32 lno)
        sys·exit(2);
 }
 
-static uint8*  hunk;
-static uint32  nhunk;
-static uint64  nmmap;
-static uint64  nmal;
 enum
 {
        NHUNK           = 20<<20,
@@ -76,42 +71,51 @@ rnd(uint32 n, uint32 m)
        return n;
 }
 
-static byte*
+static void*
 brk(uint32 n)
 {
-       byte* v;
+       byte *v;
 
        v = sys·mmap(nil, n, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
-       sys·memclr(v, n);
-       nmmap += n;
+       m->mem.nmmap += n;
        return v;
 }
 
+
 void*
 mal(uint32 n)
 {
        byte* v;
+       Mem *mem;
 
        // round to keep everything 64-bit aligned
        n = rnd(n, 8);
-       nmal += n;
-
-       // do we have enough in contiguous hunk
-       if(n > nhunk) {
 
-               // if it is big allocate it separately
-               if(n > NHUNK)
-                       return brk(n);
-
-               // allocate a new contiguous hunk
-               hunk = brk(NHUNK);
-               nhunk = NHUNK;
+       // be careful.  calling any function might invoke
+       // mal to allocate more stack.
+       if(n > NHUNK) {
+               // this call is okay - calling mal recursively
+               // won't change anything we depend on.
+               v = brk(n);
+       } else {
+               // allocate a new hunk if this one is too small
+               if(n > m->mem.nhunk) {
+                       // better not to call brk here - it might grow the stack,
+                       // causing a call to mal and the allocation of a 
+                       // new hunk behind our backs.  then we'd toss away
+                       // almost all of that new hunk and replace it.
+                       // that'd just be a memory leak - the code would still run.
+                       m->mem.hunk =
+                               sys·mmap(nil, NHUNK, PROT_READ|PROT_WRITE,
+                                       MAP_ANON|MAP_PRIVATE, 0, 0);
+                       m->mem.nhunk = NHUNK;
+                       m->mem.nmmap += NHUNK;
+               }
+               v = m->mem.hunk;
+               m->mem.hunk += n;
+               m->mem.nhunk -= n;
        }
-
-       // allocate from the contiguous hunk
-       v = hunk;
-       hunk += n;
-       nhunk -= n;
+       m->mem.nmal += n;
        return v;
 }
 
@@ -491,6 +495,44 @@ args(int32 c, uint8 **v)
                ;
 }
 
+int32
+getenvc(void)
+{
+       return envc;
+}
+
+byte*
+getenv(int8 *s)
+{
+       int32 i, j, len;
+       byte *v, *bs;
+       
+       bs = (byte*)s;
+       len = findnull(s);
+       for(i=0; i<envc; i++){
+               v = envv[i];
+               for(j=0; j<len; j++)
+                       if(bs[j] != v[j])
+                               goto nomatch;
+               if(v[len] != '=')
+                       goto nomatch;
+               return v+len+1;
+       nomatch:;
+       }
+       return nil;
+}
+
+int32
+atoi(byte *p)
+{
+       int32 n;
+       
+       n = 0;
+       while('0' <= *p && *p <= '9')
+               n = n*10 + *p++ - '0';
+       return n;
+}
+
 //func argc() int32;  // return number of arguments
 void
 sys·argc(int32 v)
@@ -579,9 +621,35 @@ check(void)
        if(sizeof(k) != 8) throw("bad k");
        if(sizeof(l) != 8) throw("bad l");
 //     prints(1"check ok\n");
+
+       uint32 z;
+       z = 1;
+       if(!cas(&z, 1, 2))
+               throw("cas1");
+       if(z != 2)
+               throw("cas2");
+       
+       z = 4;
+       if(cas(&z, 5, 6))
+               throw("cas3");
+       if(z != 4)
+               throw("cas4");
+
        initsig();
 }
 
+uint32
+xadd(uint32 *val, uint32 delta)
+{
+       uint32 v;
+       
+       for(;;){
+               v = *val;
+               if(cas(val, v, v+delta))
+                       return v+delta;
+       }
+}
+
 /*
  * map and chan helpers for
  * dealing with unknown types

diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h
index 26eb1af2ac6d5764f384ea1073f61653717fae62..a53ac51b99251ebd489404c630b8806c43754d1b 100644 (file)
--- a/src/runtime/runtime.h
+++ b/src/runtime/runtime.h
@@ -40,8 +40,11 @@ typedef      struct  Map             Map;
 typedef        struct  Gobuf           Gobuf;
 typedef        struct  G               G;
 typedef        struct  M               M;
-typedef struct Stktop          Stktop;
+typedef        struct  Stktop          Stktop;
 typedef        struct  Alg             Alg;
+typedef        struct  Lock            Lock;
+typedef        struct  Rendez  Rendez;
+typedef        struct  Mem             Mem;
 
 /*
  * per cpu declaration
@@ -57,6 +60,7 @@ enum
        // G status
        Gidle,
        Grunnable,
+       Grunning,
        Gwaiting,
        Gdead,
 };
@@ -69,6 +73,15 @@ enum
 /*
  * structures
  */
+struct Lock
+{
+       uint32  key;
+};
+struct Rendez
+{
+       Lock*   l;
+       uint32  sleeping;       // someone is sleeping (Linux)
+};
 struct String
 {
        int32   len;
@@ -111,6 +124,16 @@ struct     G
        int16   status;
        int32   goid;
        int32   selgen;         // valid sudog pointer
+       G*      runlink;
+       Lock    runlock;
+       M*      m;      // for debuggers
+};
+struct Mem
+{
+       uint8*  hunk;
+       uint32  nhunk;
+       uint64  nmmap;
+       uint64  nmal;
 };
 struct M
 {
@@ -124,6 +147,10 @@ struct     M
        byte*   moresp;
        int32   siz1;
        int32   siz2;
+       Rendez  waitr;
+       M*      waitlink;
+       int32   pid;    // for debuggers
+       Mem     mem;
 };
 struct Stktop
 {
@@ -161,6 +188,7 @@ extern      string  emptystring;
 M*     allm;
 G*     allg;
 int32  goidgen;
+extern int32   gomaxprocs;
 
 /*
  * common functions and data
@@ -195,6 +223,37 @@ int32      read(int32, void*, int32);
 int32  write(int32, void*, int32);
 void   close(int32);
 int32  fstat(int32, void*);
+bool   cas(uint32*, uint32, uint32);
+uint32 xadd(uint32*, uint32);
+void   exit1(int32);
+void   ready(G*);
+byte*  getenv(int8*);
+int32  atoi(byte*);
+void   newosproc(M *mm, G *gg, void *stk, void (*fn)(void*), void *arg);
+int32  getprocid(void);
+
+/*
+ * mutual exclusion locks.  in the uncontended case,
+ * as fast as spin locks (just a few user-level instructions),
+ * but on the contention path they sleep in the kernel.
+ */
+void   lock(Lock*);
+void   unlock(Lock*);
+void   lockinit(Lock*);
+
+/*
+ * sleep and wakeup.
+ * a Rendez is somewhere to sleep.  it is protected by the lock r->l.
+ * the caller must acquire r->l, check the condition, and if the 
+ * condition is false, call rsleep.  rsleep will atomically drop the lock
+ * and go to sleep.  a subsequent rwakeup (caller must hold r->l)
+ * will wake up the guy who is rsleeping.  the lock keeps rsleep and
+ * rwakeup from missing each other.
+ * n.b. only one proc can rsleep on a given rendez at a time.
+ */
+void   rsleep(Rendez*);
+void   rwakeup(Rendez*);
+void   rwakeupandunlock(Rendez*);
 
 /*
  * low level go -called

diff --git a/src/runtime/sys_amd64_darwin.s b/src/runtime/sys_amd64_darwin.s
index 39549cb4b3949f8ae873aaf8d7b27ee3c634212e..57eece6bef6c6dc050aea6f11106541ecefe61d8 100644 (file)
--- a/src/runtime/sys_amd64_darwin.s
+++ b/src/runtime/sys_amd64_darwin.s
@@ -6,6 +6,7 @@
 // System calls and other sys.stuff for AMD64, Darwin
 //
 
+// TODO(rsc): Either sys·exit or exit1 is wrong!
 TEXT   sys·exit(SB),1,$-8
        MOVL    8(SP), DI               // arg 1 exit status
        MOVL    $(0x2000000+1), AX      // syscall entry
@@ -13,6 +14,13 @@ TEXT sys·exit(SB),1,$-8
        CALL    notok(SB)
        RET
 
+TEXT   exit1(SB),1,$-8
+       MOVL    8(SP), DI               // arg 1 exit status
+       MOVL    $(0x2000000+1), AX      // syscall entry
+       SYSCALL
+       CALL    notok(SB)
+       RET
+
 TEXT   sys·write(SB),1,$-8
        MOVL    8(SP), DI               // arg 1 fid
        MOVQ    16(SP), SI              // arg 2 buf
@@ -80,7 +88,7 @@ TEXT sigtramp(SB),1,$24
        CALL    sighandler(SB)
        RET
 
-TEXT   sys·mmap(SB),1,$-8
+TEXT   sys·mmap(SB),7,$-8
        MOVQ    8(SP), DI               // arg 1 addr
        MOVL    16(SP), SI              // arg 2 len
        MOVL    20(SP), DX              // arg 3 prot
@@ -98,7 +106,7 @@ TEXT notok(SB),1,$-8
        MOVQ    BP, (BP)
        RET
 
-TEXT   sys·memclr(SB),1,$-8
+TEXT   sys·memclr(SB),7,$-8
        MOVQ    8(SP), DI               // arg 1 addr
        MOVL    16(SP), CX              // arg 2 count
        ADDL    $7, CX

diff --git a/src/runtime/sys_amd64_linux.s b/src/runtime/sys_amd64_linux.s
index 106159dc8e9fc4b203b490a67217a6f94c094ba5..60091e5c849a3083df534f16f556597c09597b95 100644 (file)
--- a/src/runtime/sys_amd64_linux.s
+++ b/src/runtime/sys_amd64_linux.s
@@ -8,7 +8,13 @@
 
 TEXT   sys·exit(SB),1,$0-8
        MOVL    8(SP), DI
-       MOVL    $60, AX
+       MOVL    $231, AX        // force all os threads to exit
+       SYSCALL
+       RET
+
+TEXT exit1(SB),1,$0-8
+       MOVL    8(SP), DI
+       MOVL    $60, AX // exit the current os thread
        SYSCALL
        RET
 
@@ -61,8 +67,7 @@ TEXT  sys·rt_sigaction(SB),1,$0-32
        MOVL    8(SP), DI
        MOVQ    16(SP), SI
        MOVQ    24(SP), DX
-       MOVQ    32(SP), CX
-       MOVL    CX, R10
+       MOVQ    32(SP), R10
        MOVL    $13, AX                 // syscall entry
        SYSCALL
        RET
@@ -74,11 +79,11 @@ TEXT        sigtramp(SB),1,$24-16
        CALL    sighandler(SB)
        RET
 
-TEXT   sys·mmap(SB),1,$0-32
+TEXT   sys·mmap(SB),7,$0-32
        MOVQ    8(SP), DI
        MOVL    16(SP), SI
        MOVL    20(SP), DX
-       MOVL    24(SP), CX
+       MOVL    24(SP), R10
        MOVL    28(SP), R8
        MOVL    32(SP), R9
 
@@ -102,7 +107,7 @@ TEXT        notok(SB),7,$0
        MOVQ    BP, (BP)
        RET
 
-TEXT   sys·memclr(SB),1,$0-16
+TEXT   sys·memclr(SB),7,$0-16
        MOVQ    8(SP), DI               // arg 1 addr
        MOVL    16(SP), CX              // arg 2 count (cannot be zero)
        ADDL    $7, CX
@@ -123,3 +128,74 @@ TEXT       sys·setcallerpc+0(SB),1,$0
        MOVQ    x+8(FP), BX
        MOVQ    BX, -8(AX)              // set calling pc
        RET
+
+// int64 futex(int32 *uaddr, int32 op, int32 val, 
+//     struct timespec *timeout, int32 *uaddr2, int32 val2);
+TEXT futex(SB),1,$0
+       MOVQ    8(SP), DI
+       MOVL    16(SP), SI
+       MOVL    20(SP), DX
+       MOVQ    24(SP), R10
+       MOVQ    32(SP), R8
+       MOVL    40(SP), R9
+       MOVL    $202, AX
+       SYSCALL
+       RET
+
+// int64 clone(int32 flags, void *stack, M *m, G *g, void (*fn)(void*), void *arg);
+TEXT clone(SB),7,$0
+       MOVL    8(SP), DI
+       MOVQ    16(SP), SI
+       
+       // Copy m, g, fn, arg off parent stack for use by child.
+       // Careful: Linux system call clobbers CX and R11.
+       MOVQ    24(SP), R8
+       MOVQ    32(SP), R9
+       MOVQ    40(SP), R12
+       MOVQ    48(SP), R13
+
+       MOVL    $56, AX
+       SYSCALL
+
+       // In parent, return.
+       CMPQ    AX, $0
+       JEQ     2(PC)
+       RET
+       
+       // In child, call fn(arg) on new stack
+       MOVQ    SI, SP
+       MOVQ    R8, R14 // m
+       MOVQ    R9, R15 // g
+       PUSHQ   R13
+       CALL    R12
+       
+       // It shouldn't return.  If it does, exit
+       MOVL    $111, DI
+       MOVL    $60, AX
+       SYSCALL
+       JMP     -3(PC)  // keep exiting
+
+// int64 select(int32, void*, void*, void*, void*)
+TEXT select(SB),1,$0
+       MOVL    8(SP), DI
+       MOVQ    16(SP), SI
+       MOVQ    24(SP), DX
+       MOVQ    32(SP), R10
+       MOVQ    40(SP), R8
+       MOVL    $23, AX
+       SYSCALL
+       RET
+
+// Linux allocates each thread its own pid, like Plan 9.
+// But the getpid() system call returns the pid of the 
+// original thread (the one that exec started with),
+// no matter which thread asks.  This system call,
+// which Linux calls gettid, returns the actual pid of
+// the calling thread, not the fake one.
+//
+// int32 getprocid(void)
+TEXT getprocid(SB),1,$0
+       MOVL    $186, AX
+       SYSCALL
+       RET
+

diff --git a/src/syscall/syscall_amd64_linux.s b/src/syscall/syscall_amd64_linux.s
index c6ce48cd0e47f2aa48fa36f4422dee7ae345778e..e69fe7aadd0554771e24b57e19122317a1a66bef 100644 (file)
--- a/src/syscall/syscall_amd64_linux.s
+++ b/src/syscall/syscall_amd64_linux.s
@@ -7,7 +7,9 @@
 //
 
 // func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// Trap # in AX, args in DI SI DX, return in AX DX
+// Trap # in AX, args in DI SI DX R10 R8 R9, return in AX DX
+// Note that this differs from "standard" ABI convention, which
+// would pass 4th arg in CX, not R10.
 
 TEXT   syscall·Syscall(SB),7,$-8
        MOVQ    16(SP), DI