MPQC 2.3.1
mstate.h
1//
2// mstate.h
3//
4// Copyright (C) 1996 Limit Point Systems, Inc.
5//
6// Author: Curtis Janssen <cljanss@limitpt.com>
7// Maintainer: LPS
8//
9// This file is part of the SC Toolkit.
10//
11// The SC Toolkit is free software; you can redistribute it and/or modify
12// it under the terms of the GNU Library General Public License as published by
13// the Free Software Foundation; either version 2, or (at your option)
14// any later version.
15//
16// The SC Toolkit is distributed in the hope that it will be useful,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19// GNU Library General Public License for more details.
20//
21// You should have received a copy of the GNU Library General Public License
22// along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24//
25// The U.S. Government is granted a limited license as per AL 91-7.
26//
27
28#ifdef __GNUC__
29#pragma interface
30#endif
31
32#ifndef _util_group_mstate_h
33#define _util_group_mstate_h
34
35#include <util/state/state.h>
36#include <util/state/statein.h>
37#include <util/state/stateout.h>
38#include <util/group/message.h>
39
40namespace sc {
41
45class MsgStateSend: public StateOut {
46 private:
47 // do not allow copy constructor or assignment
49 void operator=(const MsgStateSend&);
50 protected:
52 int nbuf; // the number of bytes used in the buffer
53 int bufsize; // the allocated size of the data buffer
54 char* buffer; // the data buffer
55 char* send_buffer; // the buffer used to send data (includes nbuf)
56 int nheader; // nbuf + nheader = the number of bytes in send_buffer to send
57 int* nbuf_buffer; // the pointer to the nbuf stored in the buffer
58
59 int put_array_void(const void*, int);
60 public:
62 virtual ~MsgStateSend();
63
65 virtual void flush() = 0;
66
69 void set_buffer_size(int);
70
73 int put(const ClassDesc*);
74 int put(char r);
75 int put(unsigned int r);
76 int put(int r);
77 int put(float r);
78 int put(double r);
79 int put(const char*,int);
80 int put(const int*,int);
81 int put(const unsigned int*,int);
82 int put(const float*,int);
83 int put(const double*,int);
84};
85
89class MsgStateBufRecv: public StateIn {
90 private:
91 // do not allow copy constructor or assignment
93 void operator=(const MsgStateBufRecv&);
94 protected:
96 int nbuf; // the number of bytes used in the buffer
97 int ibuf; // the current pointer withing the buffer
98 int bufsize; // the allocated size of the buffer
99 char* buffer; // the data buffer
100 char* send_buffer; // the buffer used to send data (includes nbuf)
101 int nheader; // nbuf + nheader = the number of bytes in send_buffer to send
102 int* nbuf_buffer; // the pointer to the nbuf stored in the buffer
103
104 int get_array_void(void*,int);
105
107 virtual void next_buffer() = 0;
108 public:
113
114 virtual ~MsgStateBufRecv();
115
119};
120
124 private:
125 // do not allow copy constructor or assignment
127 void operator=(const MsgStateRecv&);
128 public:
131
132 virtual ~MsgStateRecv();
133
137 int version(const ClassDesc*);
138
141 int get(const ClassDesc**);
142 int get(char&r, const char *key = 0);
143 int get(unsigned int&r, const char *key = 0);
144 int get(int&r, const char *key = 0);
145 int get(float&r, const char *key = 0);
146 int get(double&r, const char *key = 0);
147 int get(char*&);
148 int get(unsigned int*&);
149 int get(int*&);
150 int get(float*&);
151 int get(double*&);
152};
153
157class StateSend: public MsgStateSend {
158 private:
159 // do not allow copy constructor or assignment
160 StateSend(const StateSend&);
161 void operator=(const StateSend&);
162 private:
163 int target_;
164 public:
167
168 ~StateSend();
170 void target(int);
172 void flush();
173};
174
178class StateRecv: public MsgStateRecv {
179 private:
180 // do not allow copy constructor or assignment
181 StateRecv(const StateRecv&);
182 void operator=(const StateRecv&);
183 private:
184 int source_;
185 protected:
187 public:
191 void source(int);
192};
193
198 private:
199 // do not allow copy constructor or assignment
201 void operator=(const BcastStateSend&);
202 public:
205
208 void flush();
209};
210
215 private:
216 // do not allow copy constructor or assignment
218 void operator=(const BcastStateRecv&);
219 protected:
220 int source_;
222 public:
226 void source(int s);
227};
228
233 private:
234 BcastStateRecv *recv_;
235 BcastStateSend *send_;
236 public:
238 BcastState(const Ref<MessageGrp> &, int source = 0);
239
240 ~BcastState();
241
245 void bcast(int &);
246 void bcast(double &);
247 void bcast(int *&, int);
248 void bcast(double *&, int);
249 template <class T> void bcast(Ref<T>&a)
250 {
251 if (recv_) {
252 a << SavableState::restore_state(*recv_);
253 }
254 else if (send_) {
256 }
257 }
258
261 void flush();
262
266
269};
270
275 private:
276 // do not allow copy constructor or assignment
278 void operator=(const BcastStateRecv&);
279 protected:
280 int opened_;
281 int file_position_;
282 std::streambuf *buf_;
283
285 int get_array_void(void*, int);
286 public:
290 BcastStateInBin(const Ref<MessageGrp>&, const char *filename);
291
293
294 virtual int open(const char *name);
295 virtual void close();
296
297 void seek(int loc);
298 int seekable();
299 int tell();
301};
302
303}
304
305#endif
306
307// Local Variables:
308// mode: c++
309// c-file-style: "CLJ"
310// End:
BcastStateBin reads a file in written by StateInBin on node 0 and broadcasts it to all nodes so state...
Definition: mstate.h:274
void seek(int loc)
Set the current position in the file.
int use_directory()
Returns true of this object uses a directory.
BcastStateInBin(const Ref< KeyVal > &)
Create the BcastStateRecv using the default MessageGrp.
int seekable()
Return non-zero if seek does anything sensible.
void next_buffer()
Specializations must implement next_buffer().
int tell()
Return the current position in the file.
BcastStateInBin(const Ref< MessageGrp > &, const char *filename)
Create the BcastStateRecv.
BcastStateRecv does the receive part of a broadcast of an object to all nodes.
Definition: mstate.h:214
BcastStateRecv(const Ref< MessageGrp > &, int source=0)
Create the BcastStateRecv.
void next_buffer()
Specializations must implement next_buffer().
void source(int s)
Set the source node.
BcastStateSend does the send part of a broadcast of an object to all nodes.
Definition: mstate.h:197
void flush()
Flush the data remaining in the buffer.
BcastStateSend(const Ref< MessageGrp > &)
Create the BcastStateSend.
This creates and forwards/retrieves data from either a BcastStateRecv or a BcastStateSend depending o...
Definition: mstate.h:232
void flush()
Force data to be written.
void forget_references()
Call the StateOut or StateIn forget_references member.
void bcast(int &)
Broadcast data to all nodes.
void set_buffer_size(int)
Controls the amount of data that is buffered before it is sent.
BcastState(const Ref< MessageGrp > &, int source=0)
Create a BcastState object. The default source is node 0.
This class is used to contain information about classes.
Definition: class.h:158
The MsgStateBufRecv is an abstract base class that buffers objects sent through a MessageGrp.
Definition: mstate.h:89
virtual void next_buffer()=0
Specializations must implement next_buffer().
MsgStateBufRecv(const Ref< MessageGrp > &)
MsgStateBufRecv can be initialized with a MessageGrp.
void set_buffer_size(int)
The buffer size of statein and stateout objects that communicate with each other must match.
MsgStateBufRecv()
Use the default MessageGrp.
The MsgStateRecv is an abstract base class that receives objects from nodes in a MessageGrp.
Definition: mstate.h:123
int get(char *&)
These restore data saved with StateOut's put.
MsgStateRecv(const Ref< MessageGrp > &)
MsgStateRecv must be initialized with a MessageGrp.
int version(const ClassDesc *)
Returns the version of the ClassDesc.
int get(char &r, const char *key=0)
These restore data saved with StateOut's put. members.
int get(const ClassDesc **)
I only need to override get(ClassDesc**) but C++ will hide all of the other get's so I must override ...
The MsgStateSend is an abstract base class that sends objects to nodes in a MessageGrp.
Definition: mstate.h:45
int put(const char *, int)
Write the given array data.
int put(char r)
Write the given datum.
void set_buffer_size(int)
The buffer size of statein and stateout objects that communicate with each other must match.
virtual void flush()=0
Specializations must implement flush().
int put(const ClassDesc *)
I only need to override put(const ClassDesc*) but C++ will hide all of the other put's so I must over...
A template class that maintains references counts.
Definition: ref.h:332
T * pointer() const
Returns a pointer the reference counted object.
Definition: ref.h:383
static SavableState * restore_state(StateIn &si)
Restores objects saved with save_state.
void save_state(StateOut &)
Save the state of the object as specified by the StateOut object.
Restores objects that derive from SavableState.
Definition: statein.h:70
Serializes objects that derive from SavableState.
Definition: stateout.h:61
StateRecv is a concrete specialization of MsgStateRecv that does the receive part of point to point c...
Definition: mstate.h:178
void source(int)
Specify the source node.
StateRecv(const Ref< MessageGrp > &)
Create a StateRecv given a MessageGrp.
void next_buffer()
Specializations must implement next_buffer().
StateSend is a concrete specialization of MsgStateSend that does the send part of point to point comm...
Definition: mstate.h:157
void flush()
Flush the buffer.
StateSend(const Ref< MessageGrp > &)
Create a StateSend given a MessageGrp.
void target(int)
Specify the target node.

Generated at Thu Jan 19 2023 00:00:00 for MPQC 2.3.1 using the documentation package Doxygen 1.9.6.