nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove shared tydescs

Browse Source 
All tydescs are static now, there's no need to worry about
marshalling them between threads anymore.
This commit is contained in:
Marijn Haverbeke 2012-03-15 17:42:33 +01:00
parent 140d194007
commit 22bef74b55
14 changed files with 18 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mk/target.mk
View File

@ -8,7 +8,7 @@
# (resp. corelib), set this flag to 1. It will cause stage1 to use
# the snapshot runtime (resp. corelib) rather than the runtime
# (resp. corelib) from the working directory.
USE_SNAPSHOT_RUNTIME=0
USE_SNAPSHOT_RUNTIME=1
USE_SNAPSHOT_CORELIB=0
# Do not use --enforce-mut-vars in stage0, for now, as the snapshot

9
src/rt/rust_cc.cpp
View File

@ -18,9 +18,6 @@
// collection.
#define RUST_CC_FREQUENCY 5000
// defined in rust_upcall.cpp:
void upcall_s_free_shared_type_desc(type_desc *td);
using namespace std;
namespace cc {
@ -534,9 +531,6 @@ class sweep : public shape::data<sweep,shape::ptr> {
// free closed over data:
shape::data<sweep,shape::ptr>::walk_fn_contents1();
// now free the embedded type descr:
upcall_s_free_shared_type_desc((type_desc*)pair.env->td);
// now free the ptr:
task->kernel->free(pair.env);
}
@ -563,12 +557,9 @@ class sweep : public shape::data<sweep,shape::ptr> {
}
void walk_tydesc2(char kind) {
type_desc *td = *(type_desc **)dp;
switch(kind) {
case shape::SHAPE_TYDESC:
break;
case shape::SHAPE_SEND_TYDESC:
upcall_s_free_shared_type_desc(td);
break;
default: abort();
}

1
src/rt/rust_task.cpp
View File

@ -192,7 +192,6 @@ void task_start_wrapper(spawn_args *a)
// free the environment (which should be a unique closure).
const type_desc *td = env->td;
td->drop_glue(NULL, NULL, td->first_param, box_body(env));
upcall_free_shared_type_desc(env->td);
upcall_shared_free(env);
}

73
src/rt/rust_upcall.cpp
View File

@ -288,79 +288,6 @@ upcall_shared_realloc(void *ptr, size_t size) {
return args.retval;
}
/**********************************************************************
* Called to deep copy a type descriptor onto the exchange heap.
* Used when sending closures. It's possible that we should have
* a central hashtable to avoid copying and re-copying the same
* type descriptors.
*/
struct s_create_shared_type_desc_args {
const type_desc *td;
type_desc *res;
};
void upcall_s_create_shared_type_desc(s_create_shared_type_desc_args *args)
{
rust_task *task = rust_task_thread::get_task();
LOG_UPCALL_ENTRY(task);
// Copy the main part of the type descriptor:
const type_desc *td = args->td;
int n_params = td->n_params;
size_t sz = sizeof(type_desc) + sizeof(type_desc*) * (n_params+1);
args->res = (type_desc*) task->kernel->malloc(sz, "create_shared_type_desc");
memcpy(args->res, td, sizeof(type_desc));
// Recursively copy any referenced descriptors:
if (n_params == 0) {
args->res->first_param = NULL;
} else {
args->res->first_param = &args->res->descs[1];
args->res->descs[0] = args->res;
for (int i = 0; i < n_params; i++) {
s_create_shared_type_desc_args rec_args = {
td->first_param[i], 0
};
upcall_s_create_shared_type_desc(&rec_args);
args->res->first_param[i] = rec_args.res;
}
}
}
extern "C" CDECL type_desc *
upcall_create_shared_type_desc(type_desc *td) {
s_create_shared_type_desc_args args = { td, 0 };
UPCALL_SWITCH_STACK(&args, upcall_s_create_shared_type_desc);
return args.res;
}
/**********************************************************************
* Called to deep free a type descriptor from the exchange heap.
*/
void upcall_s_free_shared_type_desc(type_desc *td)
{ // n.b.: invoked from rust_cc.cpp as well as generated code
rust_task *task = rust_task_thread::get_task();
LOG_UPCALL_ENTRY(task);
if (td) {
// Recursively free any referenced descriptors:
for (unsigned i = 0; i < td->n_params; i++) {
upcall_s_free_shared_type_desc((type_desc*) td->first_param[i]);
}
task->kernel->free(td);
}
}
extern "C" CDECL void
upcall_free_shared_type_desc(type_desc *td) {
if (td) {
UPCALL_SWITCH_STACK(td, upcall_s_free_shared_type_desc);
}
}
/**********************************************************************/
struct s_vec_grow_args {

1
src/rt/rust_upcall.h
View File

@ -3,5 +3,4 @@
// Upcalls used from C code on occasion:
extern "C" CDECL void upcall_shared_free(void* ptr);
extern "C" CDECL void upcall_free_shared_type_desc(type_desc *td);

2
src/rt/rustrt.def.in
View File

@ -59,8 +59,6 @@ upcall_cmp_type
upcall_fail
upcall_free
upcall_validate_box
upcall_create_shared_type_desc
upcall_free_shared_type_desc
upcall_log_type
upcall_malloc
upcall_rust_personality

7
src/rustc/back/upcall.rs
View File

@ -16,8 +16,6 @@ type upcalls =
shared_free: ValueRef,
shared_realloc: ValueRef,
mark: ValueRef,
create_shared_type_desc: ValueRef,
free_shared_type_desc: ValueRef,
vec_grow: ValueRef,
vec_push: ValueRef,
cmp_type: ValueRef,
@ -65,11 +63,6 @@ fn declare_upcalls(targ_cfg: @session::config,
d("shared_realloc", [T_ptr(T_i8()), size_t], T_ptr(T_i8())),
mark:
d("mark", [T_ptr(T_i8())], int_t),
create_shared_type_desc:
d("create_shared_type_desc", [T_ptr(tydesc_type)],
T_ptr(tydesc_type)),
free_shared_type_desc:
dv("free_shared_type_desc", [T_ptr(tydesc_type)]),
vec_grow:
dv("vec_grow", [T_ptr(T_ptr(opaque_vec_t)), int_t]),
vec_push:

1
src/rustc/metadata/tydecode.rs
View File

@ -267,7 +267,6 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
}
'X' { ret ty::mk_var(st.tcx, parse_int(st)); }
'Y' { ret ty::mk_type(st.tcx); }
'y' { ret ty::mk_send_type(st.tcx); }
'C' {
let ck = alt check next(st) {
'&' { ty::ck_block }

1
src/rustc/metadata/tyencode.rs
View File

@ -203,7 +203,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
w.write_char(']');
}
ty::ty_type { w.write_char('Y'); }
ty::ty_send_type { w.write_char('y'); }
ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str("C&"); }
ty::ty_opaque_closure_ptr(ty::ck_box) { w.write_str("C@"); }
ty::ty_opaque_closure_ptr(ty::ck_uniq) { w.write_str("C~"); }

18
src/rustc/middle/trans/base.rs
View File

@ -559,14 +559,6 @@ fn make_take_glue(cx: block, v: ValueRef, t: ty::t) {
Store(r.bcx, r.val, v);
r.bcx
}
ty::ty_send_type {
// sendable type descriptors are basically unique pointers,
// they must be cloned when copied:
let r = Load(bcx, v);
let s = Call(bcx, bcx.ccx().upcalls.create_shared_type_desc, [r]);
Store(bcx, s, v);
bcx
}
ty::ty_fn(_) {
closure::make_fn_glue(bcx, v, t, take_ty)
}
@ -623,14 +615,6 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
ty::ty_vec(_) | ty::ty_str {
tvec::make_free_glue(bcx, PointerCast(bcx, v, type_of(ccx, t)), t)
}
ty::ty_send_type {
// sendable type descriptors are basically unique pointers,
// they must be freed.
let ccx = bcx.ccx();
let v = PointerCast(bcx, v, T_ptr(ccx.tydesc_type));
Call(bcx, ccx.upcalls.free_shared_type_desc, [v]);
bcx
}
ty::ty_fn(_) {
closure::make_fn_glue(bcx, v, t, free_ty)
}
@ -649,7 +633,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
ty::ty_box(_) | ty::ty_opaque_box {
decr_refcnt_maybe_free(bcx, Load(bcx, v0), t)
}
ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str | ty::ty_send_type {
ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str {
free_ty(bcx, Load(bcx, v0), t)
}
ty::ty_res(did, inner, tps) {

39
src/rustc/middle/trans/closure.rs
View File

@ -114,16 +114,8 @@ fn ev_to_str(ccx: @crate_ctxt, ev: environment_value) -> str {
}
}
fn mk_tydesc_ty(tcx: ty::ctxt, ck: ty::closure_kind) -> ty::t {
ret alt ck {
ty::ck_block | ty::ck_box { ty::mk_type(tcx) }
ty::ck_uniq { ty::mk_send_type(tcx) }
};
}
fn mk_tuplified_uniq_cbox_ty(tcx: ty::ctxt, cdata_ty: ty::t) -> ty::t {
let tydesc_ty = mk_tydesc_ty(tcx, ty::ck_uniq);
let cbox_ty = tuplify_cbox_ty(tcx, cdata_ty, tydesc_ty);
let cbox_ty = tuplify_cbox_ty(tcx, cdata_ty, ty::mk_type(tcx));
ret ty::mk_imm_uniq(tcx, cbox_ty);
}
@ -166,14 +158,12 @@ fn allocate_cbox(bcx: block,
Store(bcx, rc, ref_cnt);
}
fn store_uniq_tydesc(bcx: block,
cdata_ty: ty::t,
box: ValueRef,
&ti: option<@tydesc_info>) -> block {
let ccx = bcx.ccx();
fn store_tydesc(bcx: block,
cdata_ty: ty::t,
box: ValueRef,
&ti: option<@tydesc_info>) -> block {
let bound_tydesc = GEPi(bcx, box, [0, abi::box_field_tydesc]);
let {bcx, val: td} = base::get_tydesc(bcx, cdata_ty, ti);
let td = Call(bcx, ccx.upcalls.create_shared_type_desc, [td]);
Store(bcx, td, bound_tydesc);
bcx
}
@ -190,7 +180,7 @@ fn allocate_cbox(bcx: block,
let uniq_cbox_ty = mk_tuplified_uniq_cbox_ty(tcx, cdata_ty);
let {bcx, val: box} = uniq::alloc_uniq(bcx, uniq_cbox_ty);
nuke_ref_count(bcx, box);
let bcx = store_uniq_tydesc(bcx, cdata_ty, box, ti);
let bcx = store_tydesc(bcx, cdata_ty, box, ti);
(bcx, box)
}
ty::ck_block {
@ -222,19 +212,6 @@ fn store_environment(bcx: block,
bound_values: [environment_value],
ck: ty::closure_kind) -> closure_result {
fn maybe_clone_tydesc(bcx: block,
ck: ty::closure_kind,
td: ValueRef) -> ValueRef {
ret alt ck {
ty::ck_block | ty::ck_box {
td
}
ty::ck_uniq {
Call(bcx, bcx.ccx().upcalls.create_shared_type_desc, [td])
}
};
}
let ccx = bcx.ccx(), tcx = ccx.tcx;
// compute the shape of the closure
@ -551,7 +528,7 @@ fn make_opaque_cbox_take_glue(
// Take the (deeply cloned) type descriptor
let tydesc_out = GEPi(bcx, cbox_out, [0, abi::box_field_tydesc]);
let bcx = take_ty(bcx, tydesc_out, mk_tydesc_ty(tcx, ty::ck_uniq));
let bcx = take_ty(bcx, tydesc_out, ty::mk_type(tcx));
// Take the data in the tuple
let ti = none;
@ -612,7 +589,7 @@ fn make_opaque_cbox_free_glue(
trans_free(bcx, cbox)
}
ty::ck_uniq {
let bcx = free_ty(bcx, tydesc, mk_tydesc_ty(tcx, ck));
let bcx = free_ty(bcx, tydesc, ty::mk_type(tcx));
trans_shared_free(bcx, cbox)
}
}

1
src/rustc/middle/trans/shape.rs
View File

@ -298,7 +298,6 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] {
ty::ty_float(ast::ty_f) { [s_float(ccx.tcx)] }
ty::ty_uint(ast::ty_u) | ty::ty_ptr(_) { [s_uint(ccx.tcx)] }
ty::ty_type { [s_tydesc(ccx.tcx)] }
ty::ty_send_type { [s_send_tydesc(ccx.tcx)] }
ty::ty_int(ast::ty_i8) { [shape_i8] }
ty::ty_uint(ast::ty_u16) { [shape_u16] }
ty::ty_int(ast::ty_i16) { [shape_i16] }

2
src/rustc/middle/trans/type_of.rs
View File

@ -71,7 +71,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
ret T_struct([T_i8(), type_of(cx, sub1)]);
}
ty::ty_param(_, _) { T_typaram(cx.tn) }
ty::ty_send_type | ty::ty_type { T_ptr(cx.tydesc_type) }
ty::ty_type { T_ptr(cx.tydesc_type) }
ty::ty_tup(elts) {
let tys = [];
for elt in elts {

19
src/rustc/middle/ty.rs
View File

@ -82,7 +82,6 @@ export ty_rptr, mk_rptr;
export ty_rec, mk_rec;
export ty_enum, mk_enum, type_is_enum;
export ty_tup, mk_tup;
export ty_send_type, mk_send_type;
export ty_type, mk_type;
export ty_uint, mk_uint, mk_mach_uint;
export ty_uniq, mk_uniq, mk_imm_uniq, type_is_unique_box;
@ -267,7 +266,6 @@ enum sty {
ty_self([t]), // interface method self type
ty_type, // type_desc*
ty_send_type, // type_desc* that has been cloned into exchange heap
ty_opaque_box, // used by monomorphizer to represent any @ box
ty_constr(t, [@type_constr]),
ty_opaque_closure_ptr(closure_kind), // ptr to env for fn, fn@, fn~
@ -392,7 +390,7 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t {
}
alt st {
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
ty_str | ty_type | ty_send_type | ty_opaque_closure_ptr(_) |
ty_str | ty_type | ty_opaque_closure_ptr(_) |
ty_opaque_box {}
ty_param(_, _) { has_params = true; }
ty_var(_) | ty_self(_) { has_vars = true; }
@ -518,8 +516,6 @@ fn mk_param(cx: ctxt, n: uint, k: def_id) -> t { mk_t(cx, ty_param(n, k)) }
fn mk_type(cx: ctxt) -> t { mk_t(cx, ty_type) }
fn mk_send_type(cx: ctxt) -> t { mk_t(cx, ty_send_type) }
fn mk_opaque_closure_ptr(cx: ctxt, ck: closure_kind) -> t {
mk_t(cx, ty_opaque_closure_ptr(ck))
}
@ -553,7 +549,7 @@ fn maybe_walk_ty(ty: t, f: fn(t) -> bool) {
if !f(ty) { ret; }
alt get(ty).struct {
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_str | ty_send_type | ty_type | ty_opaque_box |
ty_str | ty_type | ty_opaque_box |
ty_opaque_closure_ptr(_) | ty_var(_) | ty_param(_, _) {}
ty_box(tm) | ty_vec(tm) | ty_ptr(tm) | ty_rptr(_, tm) {
maybe_walk_ty(tm.ty, f);
@ -599,7 +595,7 @@ fn fold_ty(cx: ctxt, fld: fold_mode, ty_0: t) -> t {
alt tb.struct {
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_str | ty_type | ty_send_type | ty_opaque_closure_ptr(_) |
ty_str | ty_type | ty_opaque_closure_ptr(_) |
ty_opaque_box {}
ty_box(tm) {
ty = mk_box(cx, {ty: fold_ty(cx, fld, tm.ty), mutbl: tm.mutbl});
@ -780,7 +776,7 @@ pure fn type_is_unique(ty: t) -> bool {
pure fn type_is_scalar(ty: t) -> bool {
alt get(ty).struct {
ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
ty_send_type | ty_type | ty_ptr(_) | ty_rptr(_, _) { true }
ty_type | ty_ptr(_) | ty_rptr(_, _) { true }
_ { false }
}
}
@ -884,7 +880,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
let result = alt get(ty).struct {
// Scalar and unique types are sendable
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_ptr(_) | ty_send_type | ty_str { kind_sendable }
ty_ptr(_) | ty_str { kind_sendable }
ty_type { kind_copyable }
ty_fn(f) { proto_kind(f.proto) }
ty_opaque_closure_ptr(ck_block) { kind_noncopyable }
@ -1034,7 +1030,7 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
alt get(ty).struct {
// Scalar types
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
ty_send_type | ty_type | ty_ptr(_) { result = true; }
ty_type | ty_ptr(_) { result = true; }
// Boxed types
ty_str | ty_box(_) | ty_uniq(_) | ty_vec(_) | ty_fn(_) |
ty_iface(_, _) | ty_rptr(_,_) | ty_opaque_box { result = false; }
@ -1223,7 +1219,6 @@ fn hash_type_structure(st: sty) -> uint {
h
}
ty_uniq(mt) { hash_subty(37u, mt.ty) }
ty_send_type { 38u }
ty_iface(did, tys) {
let h = hash_def(40u, did);
for typ: t in tys { h = hash_subty(h, typ); }
@ -1984,7 +1979,7 @@ mod unify {
(_, ty_bot) { nxt(expected) }
(ty_bot, _) { nxt(actual) }
(ty_nil, _) | (ty_bool, _) | (ty_int(_), _) | (ty_uint(_), _) |
(ty_float(_), _) | (ty_str, _) | (ty_send_type, _) {
(ty_float(_), _) | (ty_str, _) {
struct_cmp(cx, expected, actual, nxt)
}
(ty_param(e_n, _), ty_param(a_n, _)) if e_n == a_n {