Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset d3a1ade3 in mainline for uspace/lib/c/generic/async_sess.c


Ignore:
Timestamp:
2010-12-26T17:25:57Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
d1c041a
Parents:
d3cce52
Message:

'Exchange' is better than 'transaction', because it does not evoke ACID semantics (which we don't have).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/async_sess.c

    rd3cce52 rd3a1ade3  
    3737 *
    3838 * By the term 'session', we mean a logical data path between a client and a
    39  * server over which the client can perform multiple concurrent transactions.
    40  * Each transaction consists of one or more requests (IPC calls) which can
     39 * server over which the client can perform multiple concurrent exchanges.
     40 * Each exchange consists of one or more requests (IPC calls) which can
    4141 * be potentially blocking.
    4242 *
    4343 * Clients and servers are naturally connected using IPC phones, thus an IPC
    4444 * phone represents a session between a client and a server. In one
    45  * session, there can be many outstanding transactions. In the current
    46  * implementation each concurrent transaction takes place over a different
    47  * connection (there can be at most one active transaction per connection).
     45 * session, there can be many outstanding exchanges. In the current
     46 * implementation each concurrent exchanges takes place over a different
     47 * connection (there can be at most one active exchage per connection).
    4848 *
    4949 * Sessions make it useful for a client or client API to support concurrent
     
    5555 * There are several possible implementations of sessions. This implementation
    5656 * uses additional phones to represent sessions. Using phones both for the
    57  * session and also for its transactions/connections has several advantages:
    58  *
    59  * - to make a series of transactions over a session, the client can continue to
     57 * session and also for its exchages/connections has several advantages:
     58 *
     59 * - to make a series of exchanges over a session, the client can continue to
    6060 *   use the existing async framework APIs
    6161 * - the server supports sessions by the virtue of spawning a new connection
    6262 *   fibril, just as it does for every new connection even without sessions
    6363 * - the implementation is pretty straightforward; a very naive implementation
    64  *   would be to make each transaction using a fresh phone (that is what we
     64 *   would be to make each exchage using a fresh phone (that is what we
    6565 *   have done in the past); a slightly better approach would be to cache
    66  *   connections so that they can be reused by a later transaction within
     66 *   connections so that they can be reused by a later exchange within
    6767 *   the same session (that is what this implementation does)
    6868 *
    6969 * The main disadvantages of using phones to represent sessions are:
    7070 *
    71  * - if there are too many transactions (even cached ones), the task may hit its
     71 * - if there are too many exchanges (even cached ones), the task may hit its
    7272 *   limit on the maximum number of connected phones, which could prevent the
    7373 *   task from making new IPC connections to other tasks
    7474 * - if there are too many IPC connections already, it may be impossible to
    75  *   create a transaction by connecting a new phone thanks to the task's limit on
     75 *   create an exchange by connecting a new phone thanks to the task's limit on
    7676 *   the maximum number of connected phones
    7777 *
     
    157157}
    158158
    159 /** Start new transaction in a session.
     159/** Start new exchange in a session.
    160160 *
    161161 * @param sess_phone    Session.
    162  * @return              Phone representing the new transaction or a negative error
     162 * @return              Phone representing the new exchange or a negative error
    163163 *                      code.
    164164 */
    165 int async_transaction_begin(async_sess_t *sess)
     165int async_exchange_begin(async_sess_t *sess)
    166166{
    167167        conn_node_t *conn;
     
    219219}
    220220
    221 /** Finish a transaction.
     221/** Finish an exchange.
    222222 *
    223223 * @param sess          Session.
    224  * @param data_phone    Phone representing the transaction within the session.
    225  */
    226 void async_transaction_end(async_sess_t *sess, int data_phone)
     224 * @param data_phone    Phone representing the exchange within the session.
     225 */
     226void async_exchange_end(async_sess_t *sess, int data_phone)
    227227{
    228228        conn_node_t *conn;
Note: See TracChangeset for help on using the changeset viewer.