blob: d7add40fb147be947a8aed716d3a4e42ff4ec07a (
plain)
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++ -*- */
//=============================================================================
/**
* @file MEM_SAP.h
*
* $Id$
*
* @author Nanbor Wang <nanbor@cs.wustl.edu>
*/
//=============================================================================
#ifndef ACE_MEM_SAP_H
#define ACE_MEM_SAP_H
#include /**/ "ace/pre.h"
#include "ace/PI_Malloc.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
// MEM_SAP requries position independent pointers to work
#if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1)
#include "ace/Process_Mutex.h"
class ACE_MEM_SAP;
class ACE_Reactive_MEM_IO;
class ACE_MT_MEM_IO;
class ACE_MEM_IO;
// Internal data structure
// MEM_SAP uses to queue up
// data.
class ACE_Export ACE_MEM_SAP_Node
{
public:
// friend class ACE_MEM_SAP;
// friend class ACE_Reactive_MEM_IO;
// friend class ACE_MT_MEM_IO;
// friend class ACE_MEM_IO;
typedef ACE_Based_Pointer<ACE_MEM_SAP_Node> ACE_MEM_SAP_NODE_PTR;
/// Initialize the node with its capacity.
ACE_MEM_SAP_Node (size_t cap);
/// Get the size of the data we hold.
size_t size (void) const;
/// Get the capacity of this block of data.
size_t capacity (void) const;
/// Get the pointer to the block of data we hold.
void *data (void);
/// The maximum size of this memory block.
size_t capacity_;
/// The actualy size used.
size_t size_;
ACE_MEM_SAP_NODE_PTR next_;
};
/**
* @class ACE_MEM_SAP
*
* @brief Defines the methods of shared memory management for
* shared memory transport.
*/
class ACE_Export ACE_MEM_SAP
{
public:
// = Initialization and termination methods.
typedef ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> MALLOC_TYPE;
typedef ACE_MMAP_Memory_Pool_Options MALLOC_OPTIONS;
/// Destructor.
virtual ~ACE_MEM_SAP (void);
/**
* Initialize the MEM_SAP object.
*/
virtual int init (ACE_HANDLE handle,
const ACE_TCHAR *name,
MALLOC_OPTIONS *options) = 0;
/**
* Finalizing the MEM_SAP object. This method doesn't invoke
* the <remove> method.
*/
virtual int fini ();
/**
* 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.
*/
virtual ssize_t recv_buf (ACE_MEM_SAP_Node *&buf,
int flags,
const ACE_Time_Value *timeout) = 0;
/**
* Wait to to <timeout> amount of time to send <buf>. If <send>
* times out a -1 is returned with <errno == ETIME>. If it succeeds
* the number of bytes sent is returned. */
virtual ssize_t send_buf (ACE_MEM_SAP_Node *buf,
int flags,
const ACE_Time_Value *timeout) = 0;
/// request a buffer of size <size>. Return 0 if the <shm_malloc_> is
/// not initialized.
ACE_MEM_SAP_Node *acquire_buffer (const ssize_t size);
/// release a buffer pointed by <buf>. Return -1 if the <shm_malloc_>
/// is not initialized.
int release_buffer (ACE_MEM_SAP_Node *buf);
/// Dump the state of an object.
void dump (void) const;
/// Declare the dynamic allocation hooks.
ACE_ALLOC_HOOK_DECLARE;
protected:
// = Class initializing methods to create/connect to a shared memory pool.
/**
* Create a new shm_malloc object. Return 0 if succeed and -1
* otherwise. This method should only be called from an acceptor
* class that wants to create a new memory pool for inter process
* communication.
*/
int create_shm_malloc (const ACE_TCHAR *name,
MALLOC_OPTIONS *options);
/// Close down the share memory pool. Clean up the
/// mmap file if we are the last one using it.
int close_shm_malloc (void);
ACE_HANDLE handle_;
/// Data exchange channel.
MALLOC_TYPE *shm_malloc_;
/// Constructor. Prevent this class from being instantiated.
ACE_MEM_SAP (void);
};
#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
#include "ace/MEM_SAP.i"
#endif /* ACE_LACKS_INLINE_FUNCTIONS */
#endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1 */
#include /**/ "ace/post.h"
#endif /* ACE_SOCK_IO_H */
|
