rust/src/rt/rust_chan.h

#ifndef RUST_CHAN_H
#define RUST_CHAN_H

class rust_chan : public kernel_owned<rust_chan>,
                  public rust_cond {
public:
    RUST_REFCOUNTED_WITH_DTOR(rust_chan, destroy())
    rust_chan(rust_task *task, maybe_proxy<rust_port> *port, size_t unit_sz);

    ~rust_chan();

    rust_kernel *kernel;
    rust_task *task;
    maybe_proxy<rust_port> *port;
    size_t idx;
    circular_buffer buffer;

    void associate(maybe_proxy<rust_port> *port);
    void disassociate();
    bool is_associated();

    void send(void *sptr);

    rust_chan *clone(maybe_proxy<rust_task> *target);

    // Called whenever the channel's ref count drops to zero.
    void destroy();
};

//
// Local Variables:
// mode: C++
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
//

#endif /* RUST_CHAN_H */
Populate tree. 2010-06-24 06:03:09 +02:00			`#ifndef RUST_CHAN_H`
			`#define RUST_CHAN_H`

Work on debugging race conditions. Ports and channels have been moved to the kernel pool, since they've been known to outlive their associated task. This probably isn't the right thing to do, the life cycle needs fixed instead. Some refactorying in memory_region.cpp. Added a helper function to increment and decrement the allocation counter. This makes it easier to switch between atomic and non-atomic increments. Using atomic increments for now, although this still does not fix the problem. 2011-07-07 20:53:08 +02:00			`class rust_chan : public kernel_owned<rust_chan>,`
Move ports out into their own file, add data_message and make communication system use it (and proxies) instead of existing token scheme. 2010-07-29 01:46:13 +02:00			`public rust_cond {`
Populate tree. 2010-06-24 06:03:09 +02:00			`public:`
Sync rust_chan's deref() method with rustc's code. If the channel is associated with a port then the destructor will assert. Additionally, destruction of the object is not always appropriate. This brings the deref() method into sync with the behavior of generated rust code which only invokes destroy() once the reference count goes to 0. 2011-07-01 04:27:35 +02:00			`RUST_REFCOUNTED_WITH_DTOR(rust_chan, destroy())`
Lots of design changes around proxies and message passing. Made it so that domains can only talk to other domains via handles, and with the help of the rust_kernel. 2010-09-08 03:39:07 +02:00			`rust_chan(rust_task task, maybe_proxy<rust_port> port, size_t unit_sz);`

Populate tree. 2010-06-24 06:03:09 +02:00			`~rust_chan();`

Work on debugging race conditions. Ports and channels have been moved to the kernel pool, since they've been known to outlive their associated task. This probably isn't the right thing to do, the life cycle needs fixed instead. Some refactorying in memory_region.cpp. Added a helper function to increment and decrement the allocation counter. This makes it easier to switch between atomic and non-atomic increments. Using atomic increments for now, although this still does not fix the problem. 2011-07-07 20:53:08 +02:00			`rust_kernel *kernel;`
Populate tree. 2010-06-24 06:03:09 +02:00			`rust_task *task;`
Move ports out into their own file, add data_message and make communication system use it (and proxies) instead of existing token scheme. 2010-07-29 01:46:13 +02:00			`maybe_proxy<rust_port> *port;`
			`size_t idx;`
Added a message passing system based on lock free queues for inter-thread communication. Channels now buffer on the sending side, and no longer require blocking when sending. Lots of other refactoring and bug fixes. 2010-07-19 23:05:18 +02:00			`circular_buffer buffer;`
Populate tree. 2010-06-24 06:03:09 +02:00
Move ports out into their own file, add data_message and make communication system use it (and proxies) instead of existing token scheme. 2010-07-29 01:46:13 +02:00			`void associate(maybe_proxy<rust_port> *port);`
Populate tree. 2010-06-24 06:03:09 +02:00			`void disassociate();`
Move ports out into their own file, add data_message and make communication system use it (and proxies) instead of existing token scheme. 2010-07-29 01:46:13 +02:00			`bool is_associated();`
Added a message passing system based on lock free queues for inter-thread communication. Channels now buffer on the sending side, and no longer require blocking when sending. Lots of other refactoring and bug fixes. 2010-07-19 23:05:18 +02:00
Synthesize a flush_chan upcall right before a channel's ref_count drops to zero. This should only happen in the Rust code and not in the drop glue, or on the unwind path. This change allows the task owning the channel to block on a flush and delete its own channel. This change also cleans up some code around rust_port and rust_chan. 2010-08-09 17:15:34 +02:00			`void send(void *sptr);`
Move channel cloning logic into a method on rust_chan. This will allow us to more easily clone channels from native code. 2011-06-30 05:54:03 +02:00
			`rust_chan clone(maybe_proxy<rust_task> target);`
Move the channel destroy code into rust_chan. This lets native code more easily destroy channels since directly deleting a channel is not always the right way to destroy it. 2011-06-30 17:29:35 +02:00
			`// Called whenever the channel's ref count drops to zero.`
			`void destroy();`
Populate tree. 2010-06-24 06:03:09 +02:00			`};`

Add modeline / file-local emacs var blocks. 2010-07-28 09:36:35 +02:00			`//`
			`// Local Variables:`
			`// mode: C++`
			`// fill-column: 78;`
			`// indent-tabs-mode: nil`
			`// c-basic-offset: 4`
			`// buffer-file-coding-system: utf-8-unix`
			`// compile-command: "make -k -C .. 2>&1 \| sed -e 's/\\/x\\//x:\\//g'";`
			`// End:`
			`//`

Populate tree. 2010-06-24 06:03:09 +02:00			`#endif /* RUST_CHAN_H */`