4657 Commits

Author SHA1 Message Date
Geoffroy Couprie
a226f56600 Implement Unix domain sockets in libnative 2014-02-16 18:45:48 -08:00
Alex Crichton
553b7e67d7 Allow configuration of uid/gid/detach on processes
This just copies the libuv implementation for libnative which seems reasonable
enough (uid/gid fail on windows).

Closes 
2014-02-16 16:01:03 -08:00
bors
0ba6d4885f auto merge of : bjz/rust/tuple, r=huonw
This renames the `n*` and `n*_ref` tuple getters to `val*` and `ref*` respectively, and adds `mut*` getters. It also removes the `CloneableTuple` and `ImmutableTuple` traits.
2014-02-16 07:11:34 -08:00
Brendan Zabarauskas
f450b2b379 Remove CloneableTuple and ImmutableTuple traits
These are adequately covered by the Tuple2 trait.
2014-02-17 00:57:56 +11:00
Brendan Zabarauskas
cf0654c47c Improve naming of tuple getters, and add mutable tuple getter
Renames the `n*` and `n*_ref` tuple getters to `val*` and `ref*` respectively, and adds `mut*` getters.
2014-02-17 00:57:56 +11:00
Brendan Zabarauskas
2cd7a29013 Merge ImmutableTuple* traits into their respective Tuple* trait 2014-02-16 20:25:28 +11:00
Brendan Zabarauskas
6f39eb1a56 Delegate ToStr implementation to Show for tuples 2014-02-16 19:12:28 +11:00
Brendan Zabarauskas
bf6abf8cb3 Implement Show for 1-12 element tuples 2014-02-16 19:12:28 +11:00
bors
b36340b626 auto merge of : alexcrichton/rust/issue-12295, r=brson
The previous code erroneously assumed that 'steals > cnt' was always true, but
that was a false assumption. The code was altered to decrement steals to a
minimum of 0 instead of taking all of cnt into account.

I didn't include the exact test from  because it could run for quite
awhile, and instead set the threshold for MAX_STEALS to much lower during
testing. I found that this triggered the old bug quite frequently when running
without this fix.

Closes 
2014-02-15 23:36:26 -08:00
bors
49ba513c78 auto merge of : sfackler/rust/limit-return, r=alexcrichton
This is useful in contexts like this:

```rust
let size = rdr.read_be_i32() as uint;
let mut limit = LimitReader::new(rdr.by_ref(), size);
let thing = read_a_thing(&mut limit);
assert!(limit.limit() == 0);
```
2014-02-15 18:56:29 -08:00
bors
0c62d9d83d auto merge of : alexcrichton/rust/rustdoc-testing, r=sfackler
It's too easy to forget the `rust` tag to test something.

Closes 
2014-02-15 16:36:27 -08:00
Alex Crichton
bea7862d94 Correctly reset steals when hitting MAX_STEALS
The previous code erroneously assumed that 'steals > cnt' was always true, but
that was a false assumption. The code was altered to decrement steals to a
minimum of 0 instead of taking all of cnt into account.

I didn't include the exact test from  because it could run for quite
awhile, and instead set the threshold for MAX_STEALS to much lower during
testing. I found that this triggered the old bug quite frequently when running
without this fix.

Closes 
2014-02-15 15:54:29 -08:00
Alex Crichton
836ffb5288 Silence some unused import warnings 2014-02-15 15:53:52 -08:00
bors
d98668a559 auto merge of : huonw/rust/raii-lock, r=alexcrichton
- adds a `LockGuard` type returned by `.lock` and `.trylock` that unlocks the mutex in the destructor
- renames `mutex::Mutex` to `StaticNativeMutex` 
- adds a `NativeMutex` type with a destructor
- removes `LittleLock`
- adds `#[must_use]` to `sync::mutex::Guard` to remind people to use it
2014-02-15 15:21:28 -08:00
Huon Wilson
4668cdf3c4 Convert some unnecessary StaticNativeMutexes to NativeMutexes. 2014-02-16 10:13:56 +11:00
Huon Wilson
5d86e24ab2 std::unstable::mutex: streamline & clarify documentation. 2014-02-16 10:13:56 +11:00
Huon Wilson
0937f65999 std: add a NativeMutex type as a wrapper to destroy StaticNativeMutex.
This obsoletes LittleLock, and so it is removed.
2014-02-16 10:13:56 +11:00
Huon Wilson
b87ed605c0 std: Rename unstable::mutex::Mutex to StaticNativeMutex.
This better reflects its purpose and design.
2014-02-16 10:13:56 +11:00
Huon Wilson
75d92dbabe std: add tests for the _noguard lock/signal/wait methods on Mutex. 2014-02-16 10:13:56 +11:00
Huon Wilson
76a59fd6e2 std: add an RAII unlocker to Mutex.
This automatically unlocks its lock when it goes out of scope, and
provides a safe(ish) method to call .wait.
2014-02-16 10:13:56 +11:00
Steven Fackler
23fdbcf7dd Add a method to LimitReader to return the limit
This is useful in contexts like this:

let size = rdr.read_be_i32() as uint;
let mut limit = LimitReader::new(rdr.by_ref(), size);
let thing = read_a_thing(&mut limit);
assert!(limit.limit() == 0);
2014-02-15 14:22:56 -08:00
bors
6b025c803c auto merge of : alexcrichton/rust/snapshot, r=kballard
This notably contains the `extern mod` => `extern crate` change.

Closes 
2014-02-15 14:06:26 -08:00
bors
7762baa89b auto merge of : cmr/rust/cleanup-ptr, r=huonw 2014-02-15 09:36:26 -08:00
Corey Richardson
254c155fca impl fmt::Pointer for &T and &mut T 2014-02-15 12:11:50 -05:00
Corey Richardson
49e11630fa std: clean up ptr a bit 2014-02-15 12:11:41 -05:00
bors
fba32ea79f auto merge of : kballard/rust/env-args-bytes, r=erickt
Change `os::args()` and `os::env()` to use `str::from_utf8_lossy()`.
Add new functions `os::args_as_bytes()` and `os::env_as_bytes()` to retrieve the args/env as byte vectors instead.

The existing methods were left returning strings because I expect that the common use-case is to want string handling.

Fixes .
2014-02-15 02:36:27 -08:00
Alex Crichton
e72ddbdc25 Fix all code examples 2014-02-14 23:49:22 -08:00
Alex Crichton
a41b0c2529 extern mod => extern crate
This was previously implemented, and it just needed a snapshot to go through
2014-02-14 22:55:21 -08:00
Alex Crichton
359ac360a4 Register new snapshots
This enables the parser error for `extern mod` => `extern crate` transitions.
2014-02-14 22:55:20 -08:00
Palmer Cox
4c233d1c73 Update LimitReader to take the Reader to wrap by value 2014-02-15 00:58:44 -05:00
Palmer Cox
d4dd4c68f8 Create RefReader and RefWriter adaptor structs
RefReader and RefWriter allow a caller to pass a Reader or Writer
instance by reference to generic functions that are expecting arguments
by value.
2014-02-15 00:58:43 -05:00
Kevin Ballard
d22b1646aa Use str::from_utf8_lossy() for os::env() and friends
Parse the environment by default with from_utf8_lossy. Also provide
byte-vector equivalents (e.g. os::env_as_bytes()).

Unfortunately, setenv() can't have a byte-vector equivalent because of
Windows support, unless we want to define a setenv_bytes() that fails
under Windows for non-UTF8 (or non-UTF16).
2014-02-14 21:23:37 -08:00
Kevin Ballard
c73d5ce8ab Use str::from_utf8_lossy() in os::args(), add os::args_as_bytes()
os::args() was using str::raw::from_c_str(), which would assert if the
C-string wasn't valid UTF-8. Switch to using from_utf8_lossy() instead,
and add a separate function os::args_as_bytes() that returns the ~[u8]
byte-vectors instead.
2014-02-14 21:23:37 -08:00
Kevin Ballard
8cc8eb7b8e Add c_str::CString.as_bytes_no_nul() 2014-02-14 21:23:37 -08:00
bors
f0bad904a1 auto merge of : alexcrichton/rust/issue-8449, r=kballard
This was just waiting for compiler-rt support, which was added in 

Closes 
2014-02-14 19:31:28 -08:00
Alex Crichton
90311fc68f Enable 64-bit checked multiplication on 32-bit
This was just waiting for compiler-rt support, which was added in 

Closes 
2014-02-14 19:26:41 -08:00
bors
3f717bbe96 auto merge of : alexcrichton/rust/rollup, r=alexcrichton
The last commit has the closed PRs
2014-02-14 12:21:51 -08:00
Alex Crichton
28fa81a954 Invoke gcc with -nodefaultlibs
This will hopefully bring us closer to . We're still using gcc's idea of
"startup files", but this should prevent us from leaking in dependencies that we
don't quite want (libgcc for example once compiler-rt is what we use).
2014-02-14 08:07:46 -08:00
Alex Crichton
ee2a888860 extra: Capture stdout/stderr of tests by default
When tests fail, their stdout and stderr is printed as part of the summary, but
this helps suppress failure messages from #[should_fail] tests and generally
clean up the output of the test runner.
2014-02-14 07:46:29 -08:00
lpy
665555d58f return value/use extra::test::black_box in benchmarks 2014-02-14 07:45:34 -08:00
bors
03b324ff44 auto merge of : alexcrichton/rust/no-sleep-2, r=brson
Any single-threaded task benchmark will spend a good chunk of time in `kqueue()` on osx and `epoll()` on linux, and the reason for this is that each time a task is terminated it will hit the syscall. When a task terminates, it context switches back to the scheduler thread, and the scheduler thread falls out of `run_sched_once` whenever it figures out that it did some work.

If we know that `epoll()` will return nothing, then we can continue to do work locally (only while there's work to be done). We must fall back to `epoll()` whenever there's active I/O in order to check whether it's ready or not, but without that (which is largely the case in benchmarks), we can prevent the costly syscall and can get a nice speedup.

I've separated the commits into preparation for this change and then the change itself, the last commit message has more details.
2014-02-14 00:26:47 -08:00
bors
22c34f3c4c auto merge of : alexcrichton/rust/green-improvements, r=brson
These commits pick off some low-hanging fruit which were slowing down spawning green threads. The major speedup comes from fixing a bug in stack caching where we never used any cached stacks!

The program I used to benchmark is at the end. It was compiled with `rustc --opt-level=3 bench.rs --test` and run as `RUST_THREADS=1 ./bench --bench`. I chose to use `RUST_THREADS=1` due to  as the profiles I was getting interfered too much when all the schedulers were in play (and shouldn't be after  is fixed). All of the units below are in ns/iter as reported by `--bench` (lower is better).

|               | green | native | raw    |
| ------------- | ----- | ------ | ------ |
| osx before    | 12699 | 24030  | 19734  |
| linux before  | 10223 | 125983 | 122647 |
| osx after     |  3847 | 25771  | 20835  |
| linux after   |  2631 | 135398 | 122765 |

Note that this is *not* a benchmark of spawning green tasks vs native tasks. I put in the native numbers just to get a ballpark of where green tasks are. This is benchmark is *clearly* benefiting from stack caching. Also, OSX is clearly not 5x faster than linux, I think my VM is just much slower.

All in all, this ended up being a nice 4x speedup for spawning a green task when you're using a cached stack.

```rust
extern mod extra;
extern mod native;
use std::rt:🧵:Thread;

#[bench]
fn green(bh: &mut extra::test::BenchHarness) {
    let (p, c) = SharedChan::new();
    bh.iter(|| {
        let c = c.clone();
        spawn(proc() {
            c.send(());
        });
        p.recv();
    });
}

#[bench]
fn native(bh: &mut extra::test::BenchHarness) {
    let (p, c) = SharedChan::new();
    bh.iter(|| {
        let c = c.clone();
        native::task::spawn(proc() {
            c.send(());
        });
        p.recv();
    });
}

#[bench]
fn raw(bh: &mut extra::test::BenchHarness) {
    bh.iter(|| {
        Thread::start(proc() {}).join()
    });
}
```
2014-02-13 20:36:55 -08:00
Alex Crichton
301ff0c2df Remove two allocations from spawning a green task
Two unfortunate allocations were wrapping a proc() in a proc() with
GreenTask::build_start_wrapper, and then boxing this proc in a ~proc() inside of
Context::new(). Both of these allocations were a direct result from two
conditions:

1. The Context::new() function has a nice api of taking a procedure argument to
   start up a new context with. This inherently required an allocation by
   build_start_wrapper because extra code needed to be run around the edges of a
   user-provided proc() for a new task.

2. The initial bootstrap code only understood how to pass one argument to the
   next function. By modifying the assembly and entry points to understand more
   than one argument, more information is passed through in registers instead of
   allocating a pointer-sized context.

This is sadly where I end up throwing mips under a bus because I have no idea
what's going on in the mips context switching code and don't know how to modify
it.

Closes 
cc 
2014-02-13 20:31:17 -08:00
Alex Crichton
21a064d5a3 Don't require an allocation for on_exit messages
Instead, use an enum to allow running both a procedure and sending the task
result over a channel. I expect the common case to be sending on a channel (e.g.
task::try), so don't require an extra allocation in the common case.

cc 
2014-02-13 20:29:47 -08:00
Alex Crichton
aaead93c45 Don't allocate in LocalHeap::new()
One of these is allocated for every task, trying to cut down on allocations

cc 
2014-02-13 20:29:47 -08:00
Michael Darakananda
bf1464c413 Removed num::Orderable 2014-02-13 20:12:59 -05:00
Alex Crichton
640b22852f Rebase conflicts from this giant stack of patches
List of PRs contained in this rollup:

Closes  r=alexcrichton
Closes  r=alexcrichton
Closes  r=pcwalton
Closes  r=huonw
Closes  r=pcwalton
Closes  r=brson
Closes  r=alexcrichton
Closes  r=alexcrichton
Closes  r=kballard
Closes  r=alexcrichton
Closes  r=kballard
Closes  r=alexcrichton
Closes  r=kballard
2014-02-13 13:33:46 -08:00
Alex Crichton
76c313ceb1 Lift $dst outside the closure in write!
If you were writing to something along the lines of `self.foo` then with the new
closure rules it meant that you were borrowing `self` for the entirety of the
closure, meaning that you couldn't format other fields of `self` at the same
time as writing to a buffer contained in `self`.

By lifting the borrow outside of the closure the borrow checker can better
understand that you're only borrowing one of the fields at a time. This had to
use type ascription as well in order to preserve trait object coercions.
2014-02-13 13:05:48 -08:00
JeremyLetang
60bc76fb78 remove duplicate function from std::ptr (is_null, is_not_null, offset, mut_offset) 2014-02-13 12:54:17 -08:00
Alex Crichton
1c5295c0bf Register new snapshots 2014-02-13 12:54:17 -08:00