1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// MEM_IO.h
//
// = AUTHOR
// Nanbor Wang <nanbor@cs.wustl.edu>
//
// ============================================================================
#ifndef ACE_MEM_IO_H
#define ACE_MEM_IO_H
#include "ace/SOCK.h"
#include "ace/MEM_SAP.h"
#include "ace/Memory_Pool.h"
#include "ace/Message_Block.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
class ACE_Export ACE_MEM_IO : public ACE_SOCK, public ACE_MEM_SAP
{
// = TITLE
// Defines the methods for the ACE shared memeory wrapper I/O
// routines (e.g., send/recv).
//
// The shared memory transport uses ACE_SOCK_* class to
// implement the signaling mechanism so we can easily use the
// new mechanism with the Reactor pattern (which uses select
// under the hood.)
//
// ACE_MEM_Acceptor and ACE_MEM_Connector are used to establish
// connections. When a connection is established,
// ACE_MEM_Acceptor creates the MMAP file for data exchange and
// sends the location of the file (complete path name) to
// ACE_MEM_Connector thru the socket. ACE_MEM_Connector then
// reads the location of the file off the socket and opens up
// the same MMAP file. ACE_MEM_Stream at each side then
// contains a reference to the ACE_Mallo object using the same
// MMAP file.
//
// When sending information using methods provided in this
// class, ACE_MEM_IO requests a chunk of memory from the
// MALLOC_TYPE object, copy the data into the shared memory and
// send the memory offset (from the start of the ACE_Malloc)
// across the socket. This action also servers as a signal to
// the other end. The receiving side then reverses the
// procedures and copies the information into user buffer.
public:
// = Initialization and termination methods.
ACE_MEM_IO (void);
// Constructor.
~ACE_MEM_IO (void);
// Destructor.
ssize_t send (const void *buf,
size_t n,
int flags) ;
// Send an <n> byte buffer to the other process using shm_malloc_
// connected thru the socket.
ssize_t recv (void *buf,
size_t n,
int flags) ;
// Recv an <n> byte buffer from the shm_malloc_ thru connected socket.
ssize_t send (const void *buf,
size_t n) ;
// Send an <n> byte buffer to the other process using shm_malloc_
// connected thru the socket.
ssize_t recv (void *buf,
size_t n) ;
// Recv an <n> byte buffer from the shm_malloc_ thru connected socket.
ssize_t send (const void *buf,
size_t n,
int flags,
const ACE_Time_Value *timeout);
// Wait to to <timeout> amount of time to send up to <n> bytes into
// <buf> from <handle> (uses the <send> call). If <send> times out
// a -1 is returned with <errno == ETIME>. If it succeeds the
// number of bytes sent is returned.
ssize_t recv (void *buf,
size_t n,
int flags,
const ACE_Time_Value *timeout);
// Wait up to <timeout> amount of time to receive up to <n> bytes
// into <buf> from <handle> (uses the <recv> call). If <recv> times
// out a -1 is returned with <errno == ETIME>. If it succeeds the
// number of bytes received is returned.
ssize_t send (const void *buf,
size_t n,
const ACE_Time_Value *timeout);
// Wait to to <timeout> amount of time to send up to <n> bytes into
// <buf> from <handle> (uses the <send> call). If <send> times out
// a -1 is returned with <errno == ETIME>. If it succeeds the
// number of bytes sent is returned.
ssize_t recv (void *buf,
size_t n,
const ACE_Time_Value *timeout);
// Wait up to <timeout> amount of time to receive up to <n> bytes
// into <buf> from <handle> (uses the <recv> call). If <recv> times
// out a -1 is returned with <errno == ETIME>. If it succeeds the
// number of bytes received is returned.
ssize_t send (const ACE_Message_Block *message_block,
const ACE_Time_Value *timeout);
// Wait to to <timeout> amount of time to send the <message_block>.
// If <send> times out a -1 is returned with <errno == ETIME>. If
// it succeeds the number of bytes sent is returned.
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
/* int get_local_port (u_short &) const;
// Return the local endpoint port number. Returns 0 if successful,
// else -1.
int get_remote_port (u_short &) const;
// Return the port number of the remotely connected peer (if there
// is one). Returns 0 if successful, else -1.
*/
protected:
ssize_t fetch_recv_buf (int flags, const ACE_Time_Value *timeout = 0);
// Fetch location of next available data into <recv_buffer_>.
// As this operation read the address of the data off the socket
// using ACE::recv, <timeout> only applies to ACE::recv.
private:
void *recv_buffer_;
// Internal pointer for support recv/send.
ssize_t buf_size_;
// Record the current total buffer size of <recv_buffer_>.
ssize_t cur_offset_;
// Record the current read pointer location in <recv_buffer_>.
};
#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
#include "ace/MEM_IO.i"
#endif /* ACE_LACKS_INLINE_FUNCTIONS */
#endif /* ACE_SOCK_IO_H */
|
