rpc_slave_x.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
#include <sys/time.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.

Functions
INT	rpc_end_of_cycle (INT index, void *prpc_param[])
INT	rpc_slave_init ()
INT	rpc_slave_bor ()
INT	rpc_slave_eor ()
INT	rpc_slave_poll_live ()
INT	rpc_slave_poll_dead ()
INT	rpc_slave_stop_block ()
INT	rpc_slave_read (char *pevent)
INT	send_ready_for_cycle ()

Variables
static HNDLE	rpc_conn_master_crate
static BOOL	enable_rpc_slave
static BOOL	event_ended = FALSE
static INT	last_cycle = 0
static INT	last_event_number = 0
static INT	sent_stop_request = -1
struct readout_module	rpc_slave_module

Function Documentation

INT rpc_end_of_cycle	(	INT	index,
		void *	prpc_param[]
	)

Definition at line 49 of file rpc_slave.cpp.

References diag_print(), equipment, event_ended, event_number, last_cycle, last_event_number, and SUCCESS.

Referenced by rpc_slave_init().

{
  INT cycle_number = CINT(0);
  INT event_number = CINT(1);

  diag_print(2, "Cycle ended: RAM %d, event %d\n", cycle_number, event_number);

  // first send out "fake" zero-length events for those cycles
  // where we didn't participate
  for(INT fake_evnum=last_event_number+1; fake_evnum < event_number; 
      fake_evnum++) 
  {
    diag_print(2, "Sending fake catch-up event for %d\n", fake_evnum);
    char fake_event[sizeof(EVENT_HEADER) + sizeof(BANK_HEADER)];
    char *pevent = fake_event + sizeof(EVENT_HEADER);

    rpc_flush_event();
    bk_init32(pevent);
    bm_compose_event((EVENT_HEADER *) fake_event, equipment[0].info.event_id, 0,
                     bk_size(pevent), fake_evnum);
    bm_send_event(equipment[0].buffer_handle, fake_event,
                    sizeof(fake_event), SYNC);
    bm_flush_cache(equipment[0].buffer_handle, SYNC);
  }
 
  event_ended = true;
  last_cycle = cycle_number;
  last_event_number = event_number;

  return SUCCESS;
}

INT rpc_slave_bor

(

)

Definition at line 92 of file rpc_slave.cpp.

References crate_number, diag_print(), enable_rpc_slave, event_ended, FALSE, i, last_cycle, last_event_number, MAX_CRATES, odb_find_key(), odb_get_bool(), rpc_conn_master_crate, send_ready_for_cycle(), sent_stop_request, sprintf(), SUCCESS, and TRUE.

{
  event_ended = FALSE;
  last_event_number = 0;
  sent_stop_request = -1;
  last_cycle = 0;

  // find the master crate
  int master_crate = -1;
  for(int i = 0; i < MAX_CRATES; i++) {
    if(odb_find_key("/Equipment/Crate %d", i) != NULL) {
      BOOL master = odb_get_bool("/Equipment/Crate %d/Settings/Master", i);
      if(master) master_crate = i;
    }
  }

  // maybe we're the master...in that case, disable slave function
  if(master_crate == crate_number) {
    enable_rpc_slave = FALSE;
    diag_print(1, "Disabling RPC slave function\n");
    return SUCCESS;
  } else {
    enable_rpc_slave = TRUE;
    diag_print(1, "Enabling RPC slave function\n");
  }

  // return error if unable to find the master crate
  if(master_crate < 0) {
    diag_print(0, "Unable to locate master crate\n");
    return FE_ERR_HW;
  }
  diag_print(1, "Found master crate %d\n", master_crate);

  // establish RPC connections to the master crate
  char master_crate_label[10];
  sprintf(master_crate_label, "Crate %d", master_crate);

  cm_connect_client(master_crate_label, &rpc_conn_master_crate);
  rpc_set_option(rpc_conn_master_crate, RPC_OTRANSPORT, RPC_FTCP);
  rpc_set_option(rpc_conn_master_crate, RPC_NODELAY, TRUE);

  send_ready_for_cycle();

  return SUCCESS;
}

INT rpc_slave_eor

(

)

Definition at line 139 of file rpc_slave.cpp.

References enable_rpc_slave, rpc_conn_master_crate, and SUCCESS.

{
  if(enable_rpc_slave) {
    cm_disconnect_client(rpc_conn_master_crate, 0);
  }
  return SUCCESS;
}

INT rpc_slave_init

(

)

Definition at line 82 of file rpc_slave.cpp.

References RPC_END_OF_CYCLE, rpc_end_of_cycle(), rpc_list_mucap, and SUCCESS.

{
  // register the RPC function that we provide
  rpc_register_functions(rpc_list_mucap, NULL);
  rpc_register_function(RPC_END_OF_CYCLE, rpc_end_of_cycle);

  return SUCCESS;
}

INT rpc_slave_poll_dead

(

)

Definition at line 168 of file rpc_slave.cpp.

References enable_rpc_slave, FE_NEED_START, and SUCCESS.

{
  if(!enable_rpc_slave) {
    return SUCCESS;
  }

  return FE_NEED_START;
}

INT rpc_slave_poll_live

(

)

Definition at line 148 of file rpc_slave.cpp.

References diag_print(), enable_rpc_slave, event_ended, FALSE, FE_END_BLOCK, and SUCCESS.

{
  if(!enable_rpc_slave) {
    return SUCCESS;
  }

  // Yield to receive any pending RPCs
  cm_yield(0);

  // Have we received an end-of-event notice?
  if(event_ended) {
    event_ended = FALSE;
    diag_print(2, "event ended\n");
    return FE_END_BLOCK;
  } else {
    return SUCCESS;
  }
}

INT rpc_slave_read

(

char *

pevent)

Definition at line 197 of file rpc_slave.cpp.

References enable_rpc_slave, last_event_number, send_ready_for_cycle(), and SUCCESS.

{
  if(!enable_rpc_slave) {
    return SUCCESS;
  }

  // Fill in event number
  (((EVENT_HEADER *)pevent)-1)->serial_number = last_event_number;

  // Announce that we're ready for the next cycle

  send_ready_for_cycle();

  return SUCCESS;
}

INT rpc_slave_stop_block

(

)

Definition at line 178 of file rpc_slave.cpp.

References crate_number, enable_rpc_slave, event_number, last_event_number, rpc_conn_master_crate, RPC_REQUEST_STOP, sent_stop_request, and SUCCESS.

{
  if(!enable_rpc_slave) {
    return SUCCESS;
  }

  int event_number = last_event_number + 1;

  // Send a request to the master crate for the block to end.
  if(sent_stop_request < event_number) {
    rpc_client_call(rpc_conn_master_crate, RPC_REQUEST_STOP, crate_number, 
      event_number);
    sent_stop_request = event_number;
  }

  return SUCCESS;
}

INT send_ready_for_cycle

(

)

Definition at line 214 of file rpc_slave.cpp.

References crate_number, diag_print(), rpc_conn_master_crate, RPC_READY_FOR_CYCLE, and SUCCESS.

Referenced by rpc_slave_bor(), and rpc_slave_read().

{
  // Send "ready to go"
  struct timeval tv1, tv2;
  gettimeofday(&tv1, NULL);
  rpc_client_call(rpc_conn_master_crate, RPC_READY_FOR_CYCLE, crate_number, 0); 
  gettimeofday(&tv2, NULL);

  diag_print(2, "Waited %f microseconds for RPC_READY_FOR_CYCLE.\n",
    (tv2.tv_sec-tv1.tv_sec)*1e6 + (tv2.tv_usec-tv1.tv_usec));
   
  return SUCCESS;
}

Variable Documentation

BOOL enable_rpc_slave

static

Definition at line 28 of file rpc_slave_x.cpp.

BOOL event_ended = FALSE

static

Definition at line 30 of file rpc_slave_x.cpp.

INT last_cycle = 0

static

Definition at line 31 of file rpc_slave_x.cpp.

INT last_event_number = 0

static

Definition at line 32 of file rpc_slave_x.cpp.

HNDLE rpc_conn_master_crate

static

Definition at line 27 of file rpc_slave_x.cpp.

struct readout_module rpc_slave_module

Initial value:

= {
  rpc_slave_init,        
  NULL,                  
  NULL,                  
  rpc_slave_bor,         
  rpc_slave_eor,         
  rpc_slave_poll_live,   
  rpc_slave_poll_dead,   
  NULL,                  
  rpc_slave_stop_block,  
  rpc_slave_read,        
}

Definition at line 35 of file rpc_slave_x.cpp.

INT sent_stop_request = -1

static

Definition at line 33 of file rpc_slave_x.cpp.