最終更新 2006/12/01
RTAI - Real Time Application Interface API解説(ipc編) 
 
7 IPC
 
7.1 FIFO
int rtf_reset (unsigned int minor)
Reset a real-time FIFO

int rtf_resize (unsigned int minor, int size)
Resize a real-time FIFO

int rtf_create (unsigned int minor, int size)
Create a real-time FIFO
初期サイズsizeでリアルタイム fifo (RT - FIFO)を作り、fifo識別子をminorに割り当てます。
このfifoはカーネルスペース専用です。

int rtf_destroy (unsigned int minor)
Close a real-time FIFO

int rtf_create_handler (unsigned int minor, int(*handler)(unsigned int fifo))
Install a FIFO handler function
リアルタイムFIFOのread/write時に実行される関数のハンドラを登録します。

int rtf_put (unsigned int minor, void *buf, int count)
Write data to FIFO

int rtf_get (unsigned int minor, void *buf, int count)
Read data from FIFO

int rtf_sem_init (unsigned int minor, int value)
Initialize a binary semaphore
ファイルディスクリプタfifo 番号によって識別されたセマフォを初期化します。

int rtf_sem_post (unsigned int minor)
Posting (signaling) a semaphore

int rtf_sem_trywait (unsigned int minor)
Take a semaphore, only if the calling task is not blocked.

int rtf_sem_destroy (unsigned int minor)
Delete a semaphore

 
7.2 Mailbox 関数
int _rt_mbx_evdrp (MBX *mbx, void *msg, int msg_size, int space)
  Receives bytes as many as possible leaving the message available for another receive.

int rt_typed_mbx_init (MBX *mbx, int size, int type)
  Initializes a fully typed mailbox queueing tasks according to the specified type.

int rt_mbx_init (MBX *mbx, int size)
  Initializes a mailbox.
 メールボックスをsizeで示す大きさで初期化します。mbx はユーザが割り当てた MBX 構造を指す。 メールボックスはタスク間通信のフレキシブルな手順である。タスクは任意のサイズのメッセージをどんなメールボックバッファサイズでも送ることを可能にする。
 少なくとも最も大きいメッセージのサイズ以上のバッファを使用する必要はありません。効率が下がることを予想するかもしれませんが、通常よりも大きいメッセージでも損失なく高効率で小さなバッファを使うことができます。

int rt_mbx_delete (MBX *mbx)
  Deletes a mailbox.
 rt_mbx_init () で作成されたメールボックスを削除します。

int _rt_mbx_send (MBX *mbx, void *msg, int msg_size, int space)
  Sends a message unconditionally.
メールボックス mbx に msg_size バイトのメッセージメッセージを送ります。メッセージ全体がメールボックスにコピーされる、あるいはエラーが発生するまで、ブロックされます。もし単一ショットでメッセージが送信可能としても、受信側に高優先度のタスクがあれば、送信タスクはブロックされます。

int _rt_mbx_send_wp (MBX *mbx, void *msg, int msg_size, int space)
  Sends as many bytes as possible without blocking the calling task.

int _rt_mbx_send_if (MBX *mbx, void *msg, int msg_size, int space)
  Sends a message, only if the whole message can be passed without blocking the calling task.

int _rt_mbx_send_until (MBX *mbx, void *msg, int msg_size, RTIME time, int space)
  Sends a message with absolute timeout.

int _rt_mbx_send_timed (MBX *mbx, void *msg, int msg_size, RTIME delay, int space)
  Sends a message with relative timeout.

int _rt_mbx_receive (MBX *mbx, void *msg, int msg_size, int space)
  Receives a message unconditionally.
メールボックス mbx から msg_size バイトのメッセージを受信します。メッセージの全部が到着するか、あるいはエラーが発生するまで、受信はブロックされる。

int _rt_mbx_receive_wp (MBX *mbx, void *msg, int msg_size, int space)
  Receives bytes as many as possible, without blocking the calling task.

int _rt_mbx_receive_if (MBX *mbx, void *msg, int msg_size, int space)
  Receives a message only if the whole message can be passed without blocking the calling task.

int _rt_mbx_receive_until (MBX *mbx, void *msg, int msg_size, RTIME time, int space)
  Receives a message with absolute timeout.

int _rt_mbx_receive_timed (MBX *mbx, void *msg, int msg_size, RTIME delay, int space)
  Receives a message with relative timeout.

int _rt_mbx_ovrwr_send (MBX *mbx, void *msg, int msg_size, int space)
  Sends a message overwriting what already in the buffer if there is no place for the message.

MBX * _rt_typed_named_mbx_init (unsigned long mbx_name, int size, int qtype)
  Initializes a specifically typed (fifo queued, priority queued or resource queued) mailbox identified by a name.

int rt_named_mbx_delete (MBX *mbx)
  Deletes a named mailbox.

 

7.3 Message handling 関数
RT_TASK * rt_send (RT_TASK *task, unsigned int msg)
  Send a message.
 メッセージをtaskで指定されるタスクに送ります。 もし受信タスクがメッセージ受信準備ができていれば、 送信タスクはブロックされません、しかし、もし受取タスクがより高いプライオリティを持っているなら、その送信側の実行はプリエンプトされます。 受信準備ができていなければ送信タスクはブロックされて、プライオリティオーダーで受信待ち行列に入れられる。

RT_TASK * rt_send_if (RT_TASK *task, unsigned int msg)
  Send a message, only if the calling task will not be blocked.

RT_TASK * rt_send_until (RT_TASK *task, unsigned int msg, RTIME time)
RT_TASK * rt_send_timed (RT_TASK *task, unsigned int msg, RTIME delay)
RT_TASK * rt_rpc (RT_TASK *task, unsigned int to_do, unsigned int *result)
  Make a remote procedure call.

RT_TASK * rt_rpc_if (RT_TASK *task, unsigned int to_do, unsigned int *result)
  Make a remote procedure call, only if the calling task will not be blocked.

RT_TASK * rt_rpc_until (RT_TASK *task, unsigned int to_do, unsigned int *result, RTIME time)  Make a remote procedure call with an absolute timeout.

RT_TASK * rt_rpc_timed (RT_TASK *task, unsigned int to_do, unsigned int *result, RTIME delay)  Make a remote procedure call with a relative timeout.

int rt_isrpc (RT_TASK *task)
  Check if sender waits for reply or not.

RT_TASK * rt_return (RT_TASK *task, unsigned int result)
  Return (sends) the result back to the task that made the related remote procedure call.

RT_TASK * rt_evdrp (RT_TASK *task, unsigned int *msg)
  Eavedrop (spy) the content of a message.

RT_TASK * rt_receive (RT_TASK *task, unsigned int *msg)
  Receive a message.
 taskによって指定されたタスクからメッセージを受けとります。もしtask=0なら、全ての送信タスクからのメッセージを受け入れます。もしペンディングメッセージがあるなら、 受信タスクはブロックしません、しかし、もし受信メッセージを 送信したタスクがより高いプライオリティを持っているなら、プリエンプトされます。もしそのメッセージが、タスクを rpcing するならば、普通メッセージの返送を待ちますから、この場合タスクはブロックしないでしょう。

RT_TASK * rt_receive_if (RT_TASK *task, unsigned int *msg)
  Receive a message, only if the calling task is not blocked.

RT_TASK * rt_receive_until (RT_TASK *task, unsigned int *msg, RTIME time)
  Receive a message with an absolute timeout.

RT_TASK * rt_receive_timed (RT_TASK *task, unsigned int *msg, RTIME delay)
  Receive a message with a relative timeout.

RT_TASK * rt_rpcx (RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize)
  Make an extended remote procedure call.

RT_TASK * rt_rpcx_if (RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize)
  Make an extended remote procedure call, only if the calling task will not be blocked.

RT_TASK * rt_rpcx_until (RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME time)  Make an extended remote procedure call with absolute timeout.

RT_TASK * rt_rpcx_timed (RT_TASK *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME delay)
  Make an extended remote procedure call with a relative timeout.

RT_TASK * rt_sendx (RT_TASK *task, void *msg, int size)
  Send an extended message.

RT_TASK * rt_sendx_if (RT_TASK *task, void *msg, int size)
  Send an extended message, only if the calling task will not be blocked.

RT_TASK * rt_sendx_until (RT_TASK *task, void *msg, int size, RTIME time)
  Send an extended message with absolute timeout.

RT_TASK * rt_sendx_timed (RT_TASK *task, void *msg, int size, RTIME delay)
  Send an extended message with relative timeout.

RT_TASK * rt_returnx (RT_TASK *task, void *msg, int size)
  Return (sends) an extended result back to the task that made the related extended remote procedure call.

RT_TASK * rt_evdrpx (RT_TASK *task, void *msg, int size, int *len)
  Eavedrop (spy) the content of an extended message.

RT_TASK * rt_receivex (RT_TASK *task, void *msg, int size, int *len)
  Receive an extended message.

RT_TASK * rt_receivex_if (RT_TASK *task, void *msg, int size, int *len)
  Receive an extended message, only if the calling task is not blocked.

RT_TASK * rt_receivex_until (RT_TASK *task, void *msg, int size, int *len, RTIME time)
  Receive an extended message with an absolute timeout.

RT_TASK * rt_receivex_timed (RT_TASK *task, void *msg, int size, int *len, RTIME delay)
  Receive an extended message with a relative timeout.


 

7.4 セマフォ 関数
 

void rt_typed_sem_init (SEM *sem, int value, int type)
  Initialize a specifically typed (counting, binary, resource) semaphore.

void rt_sem_init (SEM *sem, int value)
  Initialize a counting semaphore.
 semで指定されるカウンティング fifo queueing セマフォを初期化します。
 セマフォはリアルタイムタスク間で通信と同期化のために使われることができます。

int rt_sem_delete (SEM *sem)
  Delete a semaphore.
 rt_sem_init () で作られたセマフォをデリートします。

int rt_sem_signal (SEM *sem)
  Signaling a semaphore.
 セマフォにイベントを与えます。
 多くは、タスクがクリティカルリージョンにから出るときに呼ばれます。セマフォ値を増加してテストします。 もしセマフォ値 =<0 ならば、このセマフォの待ち行列で最初のタスクが実行可能にされます。rt_sem_signal は呼び出し側タスクをブロックしません。

int rt_sem_broadcast (SEM *sem)
  Signaling a semaphore.

int rt_sem_wait (SEM *sem)
  Take a semaphore.
 このセマフォにイベントが発生するのを待ちます。
 多くは、タスクがクリティカルリージョンに入るときに呼ばれます。セマフォ値を減算してテストをします。もし、セマフォ値 >=0 であれば、直ちに戻ります。さもなければ呼び出しタスクはブロックされて、待ち行列に入れられます。待ち行列のプライオリティオーダーかFIFOベースかはコンパイル時オプション SEM_PRIORD によって決定されます。

int rt_sem_wait_if (SEM *sem)
  Take a semaphore, only if the calling task is not blocked.

int rt_sem_wait_until (SEM *sem, RTIME time)
  Wait a semaphore with timeout.

int rt_sem_wait_timed (SEM *sem, RTIME delay)
  Wait a semaphore with timeout.

int rt_sem_wait_barrier (SEM *sem)
  Wait on a semaphore barrier.

int rt_cond_signal (CND *cnd)
  Wait for a signal to a conditional variable.

int rt_cond_wait (CND *cnd, SEM *mtx)
  Wait for a signal to a conditional variable.

int rt_cond_wait_until (CND *cnd, SEM *mtx, RTIME time)
  Wait a semaphore with timeout.

int rt_cond_wait_timed (CND *cnd, SEM *mtx, RTIME delay)
  Wait a semaphore with timeout.

int rt_rwl_init (RWL *rwl)
  Initialize a multi readers single writer lock.

int rt_rwl_delete (RWL *rwl)
  destroys a multi readers single writer lock.

int rt_rwl_rdlock (RWL *rwl)
  acquires a multi readers single writer lock for reading.

int rt_rwl_rdlock_if (RWL *rwl)
  try to acquire a multi readers single writer lock just for reading.

int rt_rwl_rdlock_until (RWL *rwl, RTIME time)
  try to acquire a multi readers single writer lock for reading within an absolute deadline time.

int rt_rwl_rdlock_timed (RWL *rwl, RTIME delay)
  try to acquire a multi readers single writer lock for reading within a relative deadline time.

int rt_rwl_wrlock (RWL *rwl)
  acquires a multi readers single writer lock for wrtiting.

int rt_rwl_wrlock_if (RWL *rwl)
  acquires a multi readers single writer lock for writing.

int rt_rwl_wrlock_until (RWL *rwl, RTIME time)
  try to acquire a multi readers single writer lock for writing within an absolute deadline time.

int rt_rwl_wrlock_timed (RWL *rwl, RTIME delay)
  try to acquire a multi readers single writer lock for writing within a relative deadline time.

int rt_rwl_unlock (RWL *rwl)
  unlock an acquired multi readers single writer lock.

int rt_spl_init (SPL *spl)
  Initialize a spinlock.

int rt_spl_delete (SPL *spl)
  Initialize a spinlock.

int rt_spl_lock (SPL *spl)
  Acquire a spinlock.

int rt_spl_lock_if (SPL *spl)
  Acquire a spinlock without waiting.

int rt_spl_lock_timed (SPL *spl, unsigned long ns)  Acquire a spinlock with timeout.

int rt_spl_unlock (SPL *spl)  Release an owned spinlock.

SEM * _rt_typed_named_sem_init (unsigned long sem_name, int value, int type)  Initialize a specifically typed (counting, binary, resource) semaphore identified by a name.

int rt_named_sem_delete (SEM *sem)  Delete a semaphore initialized in named mode.

RWL * _rt_named_rwl_init (unsigned long rwl_name)  Initialize a multi readers single writer lock identified by a name.

int rt_named_rwl_delete (RWL *rwl)  Delete a multi readers single writer lock in named mode.

SPL * _rt_named_spl_init (unsigned long spl_name)  Initialize a spinlock identified by a name.

int rt_named_spl_delete (SPL *spl)  Delete a spinlock in named mode.

 

7.5 シェアードメモリのインプリメンテーション
void * rt_shm_alloc (unsigned long name, int size, int suprt)
  Allocate a chunk of memory to be shared inter-intra kernel modules and Linux processes.
 最初のコールだけが与えられた名称で実際のアロケートを行います。続く同一名でのコールでユーザスペースにマッピングしたポインタを返す。

void * rt_heap_open (unsigned long name, int size, int suprt)
  Open/create a named group real time heap to be shared inter-intra kernel modules and Linux processes.
 
7.6 ダイナミックメモリアロケーション サービス
int rtheap_init (rtheap_t *heap, void *heapaddr, u_long heapsize, u_long pagesize)
  Initialize a memory heap.

void rtheap_destroy (rtheap_t *heap)
  Destroys a memory heap.

void * rtheap_alloc (rtheap_t *heap, u_long size, int mode)
  Allocate a memory block from a memory heap.
i
nt rtheap_free (rtheap_t *heap, void *block)
  Release a memory block to a memory heap.

 


Guest No.