AlcapDAQ  1
Macros | Functions | Variables
rpc_master.cpp File Reference
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
#include "midas.h"
#include "crate.h"
#include "diag.h"
#include "odb_wrapper.h"
#include "rpc_mucap.h"

Go to the source code of this file.

Macros

#define DEFINE_RPC_LIST
 

Functions

INT rpc_ready_for_cycle (INT index, void *prpc_param[])
 
INT rpc_request_stop (INT index, void *prpc_param[])
 
INT rpc_master_init ()
 
INT rpc_master_pre_bor ()
 
INT rpc_master_bor ()
 
INT rpc_master_eor ()
 
INT rpc_master_poll_live ()
 
INT rpc_master_poll_dead ()
 
INT rpc_master_read (char *pevent)
 
BOOL crate_is_participating (INT crate_number)
 
INT cycle_ram ()
 

Variables

struct {
   BOOL   enabled
 
   BOOL   synchronous
 
   BOOL   participating
 
   BOOL   ready [3]
 
   HNDLE   conn
 
} crate [MAX_CRATES]
 
INT event_number
 
INT request_stop_event
 
static BOOL enable_rpc_master
 
struct readout_module rpc_master_module
 

Macro Definition Documentation

#define DEFINE_RPC_LIST

Definition at line 13 of file rpc_master.cpp.

Function Documentation

BOOL crate_is_participating ( INT  crate_number)

Definition at line 193 of file rpc_master.cpp.

194 {
195  return crate[crate_number].participating;
196 }
INT cycle_ram ( )

Definition at line 202 of file rpc_master.cpp.

Referenced by rpc_master_poll_dead(), rpc_master_read(), and vmic_ttl_start_block().

203 {
204  return ((event_number + 1) % 2) + 1;
205 }
INT rpc_master_bor ( )

Definition at line 91 of file rpc_master.cpp.

References conn, crate, crate_number, enable_rpc_master, enabled, event_number, i, MAX_CRATES, odb_find_key(), odb_get_bool(), request_stop_event, sprintf(), SUCCESS, and TRUE.

92 {
93  if(!enable_rpc_master) {
94  return SUCCESS;
95  }
96 
97  for(int i = 0; i < MAX_CRATES; i++) {
98  if(i != crate_number) {
99  bool enabled = false;
100  if(odb_find_key("/Equipment/Crate %d", i) != NULL) {
101  enabled = odb_get_bool("/Equipment/Crate %d/Settings/Enabled", i);
102  }
103  crate[i].enabled = enabled;
104 
105 
106  if(enabled) {
107  crate[i].synchronous =
108  odb_get_bool("/Equipment/Crate %d/Settings/Synchronous", i);
109 
110  char crate_label[10];
111  sprintf(crate_label, "Crate %d", i);
112  cm_connect_client(crate_label, &crate[i].conn);
113  rpc_set_option(crate[i].conn, RPC_OTRANSPORT, RPC_FTCP);
114  rpc_set_option(crate[i].conn, RPC_NODELAY, TRUE);
115  }
116  }
117  }
118 
119  event_number = 1;
120  request_stop_event = 0;
121 
122  return SUCCESS;
123 }
INT rpc_master_eor ( )

Definition at line 128 of file rpc_master.cpp.

References conn, crate, crate_number, enable_rpc_master, enabled, i, MAX_CRATES, and SUCCESS.

129 {
130  if(!enable_rpc_master) {
131  return SUCCESS;
132  }
133 
134  for(int i = 0; i < MAX_CRATES; i++) {
135  if(i != crate_number && crate[i].enabled) {
136  cm_disconnect_client(crate[i].conn, 0);
137  }
138  }
139 
140  return SUCCESS;
141 }
INT rpc_master_init ( )

Definition at line 55 of file rpc_master.cpp.

References crate_number, enable_rpc_master, odb_get_bool(), rpc_list_mucap, RPC_READY_FOR_CYCLE, rpc_ready_for_cycle(), RPC_REQUEST_STOP, rpc_request_stop(), and SUCCESS.

56 {
57  // Determine whether we ought to be the master
58  enable_rpc_master =
59  odb_get_bool("/Equipment/Crate %d/Settings/Master", crate_number);
60  if(!enable_rpc_master) {
61  return SUCCESS;
62  }
63 
64  // register the RPC function that we provide
65  rpc_register_functions(rpc_list_mucap, NULL);
66  rpc_register_function(RPC_READY_FOR_CYCLE, rpc_ready_for_cycle);
67  rpc_register_function(RPC_REQUEST_STOP, rpc_request_stop);
68 
69  return SUCCESS;
70 }
INT rpc_master_poll_dead ( )

Definition at line 250 of file rpc_master.cpp.

References crate, crate_number, cycle_ram(), enable_rpc_master, enabled, FALSE, FE_NEED_START, i, MAX_CRATES, ready, SUCCESS, synchronous, and TRUE.

251 {
252  if(!enable_rpc_master) {
253  return SUCCESS;
254  }
255 
256  // Yield to receive any pending RPCs
257  cm_yield(0);
258 
259  // Have we received notice from each of the enabled crates that
260  // it is ready to start?
261 
262  BOOL ready_to_start = TRUE;
263 
264  INT ram = cycle_ram();
265 
266  for(int i = 0; i < MAX_CRATES; i++) {
267  if(i != crate_number && crate[i].enabled && crate[i].synchronous &&
268  !(crate[i].ready[ram] || crate[i].ready[0])) {
269  ready_to_start = FALSE;
270  break;
271  }
272  }
273 
274  if(ready_to_start) {
275  for(int i = 0; i < MAX_CRATES; i++) {
276  crate[i].participating = (crate[i].ready[ram] || crate[i].ready[0]);
277 
278  crate[i].ready[ram] = FALSE;
279  crate[i].ready[0] = FALSE;
280  }
281 
282  return FE_NEED_START;
283  } else {
284  return SUCCESS;
285  }
286 }
INT rpc_master_poll_live ( )

Definition at line 232 of file rpc_master.cpp.

References enable_rpc_master, event_number, FE_NEED_STOP, request_stop_event, and SUCCESS.

233 {
234  if(!enable_rpc_master) {
235  return SUCCESS;
236  }
237 
238  // Yield to receive any pending RPCs
239  cm_yield(0);
240 
241  // Have we received a request to end the event?
242  if(request_stop_event == event_number) {
243  // diag_print(2, "Stopping event.\n");
244  return FE_NEED_STOP;
245  }
246 
247  return SUCCESS;
248 }
INT rpc_master_pre_bor ( )

Definition at line 75 of file rpc_master.cpp.

References crate, diag_print(), FALSE, i, MAX_CRATES, and SUCCESS.

76 {
77  diag_print(1, "Clearing crate ready flags\n");
78 
79  for(int i = 0; i < MAX_CRATES; i++) {
80  for(int j = 0; j <= 2; j++) {
81  crate[i].ready[j] = FALSE;
82  }
83  }
84 
85  return SUCCESS;
86 }
INT rpc_master_read ( char *  pevent)

Definition at line 207 of file rpc_master.cpp.

References conn, crate, crate_number, cycle_ram(), diag_print(), enable_rpc_master, enabled, event_number, i, MAX_CRATES, participating, RPC_END_OF_CYCLE, SUCCESS, and synchronous.

208 {
209  if(!enable_rpc_master) {
210  return SUCCESS;
211  }
212 
213  int ram = cycle_ram();
214 
215  // Send a message to other crates that the cycle is now over
216  for(int i = 0; i < MAX_CRATES; i++) {
217  if(i != crate_number && crate[i].enabled) {
218  if(crate[i].synchronous || crate[i].participating) {
219  diag_print(2, "Sending RPC_END_OF_CYCLE to crate %d RAM %d event %d\n",
220  i, ram, event_number);
221  rpc_client_call(crate[i].conn, RPC_END_OF_CYCLE, ram, event_number);
222  }
223  }
224  }
225 
226  // Increment event number
227  event_number++;
228 
229  return SUCCESS;
230 }
INT rpc_ready_for_cycle ( INT  index,
void *  prpc_param[] 
)

Definition at line 146 of file rpc_master.cpp.

References crate, crate_number, diag_print(), SUCCESS, and TRUE.

Referenced by rpc_master_init().

147 {
148  INT crate_number = CINT(0);
149  INT ram_cycle = CINT(1);
150 
151  diag_print(2, "Crate %d is ready for a new cycle on ram=%d.\n",
152  crate_number, ram_cycle);
153 
154  crate[crate_number].ready[ram_cycle] = TRUE;
155 
156 #if 0
157  if(ram_cycle == 0) {
158  crate[crate_number].ready[1] = crate[crate_number].ready[2] = TRUE;
159  } else {
160  crate[crate_number].ready[ram_cycle] = TRUE;
161  }
162 #endif
163 
164  return SUCCESS;
165 }
INT rpc_request_stop ( INT  index,
void *  prpc_param[] 
)

Definition at line 170 of file rpc_master.cpp.

References crate_number, diag_print(), event_number, request_stop_event, and SUCCESS.

Referenced by rpc_master_init().

171 {
172  INT crate_number = CINT(0);
173  INT event_number_in = CINT(1);
174 
175  diag_print(2, "Crate %d requests end of block %d\n",
176  crate_number, event_number_in);
177 
178  if(event_number_in != event_number) {
179  diag_print(0,
180  "Crate %d requests end of block %d--not the right event number (%d)\n",
181  crate_number, event_number_in, event_number);
182  return SUCCESS;
183  }
184 
185  request_stop_event = event_number_in;
186 
187  return SUCCESS;
188 }

Variable Documentation

HNDLE conn

Definition at line 31 of file rpc_master.cpp.

Referenced by rpc_master_bor(), rpc_master_eor(), and rpc_master_read().

struct { ... } crate[MAX_CRATES]

Referenced by crate_is_participating(), MCaenCompProcessRaw_init(), rpc_master_bor(), rpc_master_eor(), rpc_master_poll_dead(), rpc_master_pre_bor(), rpc_master_read(), rpc_ready_for_cycle(), and s500_read().

BOOL enable_rpc_master
static

Definition at line 36 of file rpc_master.cpp.

Referenced by rpc_master_bor(), rpc_master_eor(), rpc_master_init(), rpc_master_poll_dead(), rpc_master_poll_live(), and rpc_master_read().

BOOL enabled

Definition at line 27 of file rpc_master.cpp.

Referenced by allPacketsReceived(), caenV767_bor(), caenV767_eor(), caenV767_poll_live(), caenV767_pre_bor(), caenV767_read(), dl40x_bor(), dl40x_eor(), dl40x_read(), eb_begin_of_run(), forgetPackets(), load_fragment(), lrs2249_bor(), lrs2249_read(), new_fadc_read(), receivePackets(), rpc_master_bor(), rpc_master_eor(), rpc_master_poll_dead(), rpc_master_read(), s500_bor(), s500_read(), setupRegs(), sis3600_bor(), sis3600_eor(), sis3600_poll_live(), sis3600_read(), UpdateDetectorBankNameMap(), v1724_eor(), v1724_exit(), v1724_init(), v1724_pre_bor(), v1724_read(), and v1724_readout().

INT event_number

Definition at line 34 of file rpc_master.cpp.

Referenced by cycle_ram(), process_file(), rpc_end_of_cycle(), rpc_master_bor(), rpc_master_poll_live(), rpc_master_read(), rpc_request_stop(), and rpc_slave_stop_block().

BOOL participating

Definition at line 29 of file rpc_master.cpp.

Referenced by rpc_master_read().

BOOL ready[3]

Definition at line 30 of file rpc_master.cpp.

Referenced by floppy_ttl_start_block(), and rpc_master_poll_dead().

INT request_stop_event

Definition at line 35 of file rpc_master.cpp.

Referenced by rpc_master_bor(), rpc_master_poll_live(), and rpc_request_stop().

struct readout_module rpc_master_module
Initial value:
= {
rpc_master_init,
NULL,
rpc_master_pre_bor,
rpc_master_bor,
rpc_master_eor,
rpc_master_poll_live,
rpc_master_poll_dead,
NULL,
NULL,
rpc_master_read,
}

Definition at line 38 of file rpc_master.cpp.

BOOL synchronous

Definition at line 28 of file rpc_master.cpp.

Referenced by rpc_master_poll_dead(), and rpc_master_read().

Generated by   doxygen 1.8.4