void network::create_grid_four_connections() {
for (unsigned int index = 0; index < m_num_osc; index++) {
const int upper_index = index - m_width;
const int lower_index = index + m_width;
const int left_index = index - 1;
const int right_index = index + 1;
unsigned int node_row_index = std::ceil(index / m_width);
if (upper_index >= 0) {
set_connection(index, upper_index);
}
if (lower_index < m_num_osc) {
set_connection(index, lower_index);
}
if ((left_index >= 0) && (std::ceil(left_index / m_width) == node_row_index)) {
set_connection(index, left_index);
}
if ((right_index < m_num_osc) && (std::ceil(right_index / m_width) == node_row_index)) {
set_connection(index, right_index);
}
}
}
void network::create_list_bidir_connections() {
for (size_t index = 0; index < m_num_osc; index++) {
if (index > 0) {
set_connection(index, index - 1);
}
if (index < (m_num_osc - 1)) {
set_connection(index, index + 1);
}
}
}
void remote488_device::process_input_msgs()
{
uint8_t data;
char msg_ch;
while ((msg_ch = recv_update(data)) != 0) {
set_connection(true);
LOG("%.6f Rx %c %02x\n" , machine().time().as_double() , msg_ch , data);
switch (msg_ch) {
case MSG_SIGNAL_CLEAR:
m_flush_bytes = false;
update_signals_from_rem(0 , data);
break;
case MSG_SIGNAL_SET:
m_flush_bytes = false;
update_signals_from_rem(data , 0);
break;
case MSG_DATA_BYTE:
if (m_flush_bytes) {
LOG("Flushed\n");
} else {
m_poll_timer->reset();
recvd_data_byte(data , false);
return;
}
break;
case MSG_END_BYTE:
if (m_flush_bytes) {
LOG("Flushed\n");
m_flush_bytes = false;
} else {
m_poll_timer->reset();
recvd_data_byte(data , true);
return;
}
break;
case MSG_PP_DATA:
m_flush_bytes = false;
m_pp_data = data;
m_pp_requested = false;
update_pp_dio();
break;
case MSG_ECHO_REQ:
send_update(MSG_ECHO_REPLY , 0);
break;
default:
break;
}
}
if (!m_poll_timer->enabled()) {
m_poll_timer->adjust(attotime::from_usec(POLL_PERIOD_US) , 0 , attotime::from_usec(POLL_PERIOD_US));
}
}
void network::create_grid_eight_connections() {
create_grid_four_connections(); /* create connection with right, upper, left, lower neighbor */
for (unsigned int index = 0; index < m_num_osc; index++) {
const int upper_index = index - m_width;
const int upper_left_index = index - m_width - 1;
const int upper_right_index = index - m_width + 1;
const int lower_index = index + m_width;
const int lower_left_index = index + m_width - 1;
const int lower_right_index = index + m_width + 1;
const int left_index = index - 1;
const int right_index = index + 1;
const int node_row_index = std::floor(index / m_width);
const int upper_row_index = node_row_index - 1;
const int lower_row_index = node_row_index + 1;
if ((upper_left_index >= 0) && (std::floor(upper_left_index / m_width) == upper_row_index)) {
set_connection(index, upper_left_index);
}
if ((upper_right_index >= 0) && (std::floor(upper_right_index / m_width) == upper_row_index)) {
set_connection(index, upper_right_index);
}
if ((lower_left_index < m_num_osc) && (std::floor(lower_left_index / m_width) == lower_row_index)) {
set_connection(index, lower_left_index);
}
if ((lower_right_index < m_num_osc) && (std::floor(lower_right_index / m_width) == lower_row_index)) {
set_connection(index, lower_right_index);
}
}
}
void remote488_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id) {
case TMR_ID_POLL:
process_input_msgs();
break;
case TMR_ID_HEARTBEAT:
if (m_connected && m_connect_cnt && --m_connect_cnt == 0) {
set_connection(false);
}
send_update(MSG_ECHO_REQ , 0);
break;
default:
break;
}
}
void remote488_device::device_reset()
{
m_no_propagation = true;
m_in_signals = 0xff;
m_bus->atn_w(this , 1);
m_bus->eoi_w(this , 1);
m_bus->ifc_w(this , 1);
m_bus->ren_w(this , 1);
m_bus->srq_w(this , 1);
m_out_signals = 0xff;
m_no_propagation = false;
// Fake disconnection
m_connected = true;
set_connection(false);
bus_reset();
}
Connection::HeartbeatHandler::HeartbeatHandler(Connection* connection)
: Handler(new OptionsRequest()) {
set_connection(connection);
}
void main (int argc, char* argv[])
{
int i;
char input_name[256] = "";
char output_name[256] = "";
long idle_limit = 2000; /* default threshold for idleness in millisec. */
long elapsed;
char parse_line[500];
char discard[50];
char *cursor;
char *vp;
/* Parse the command line */
i = 1;
while (i < argc) {
if (strcmp (argv[i], "-r") == 0) {
if (++i >= argc) Usage (argv[0]);
strcpy (input_name, argv[i]);
}
else if (strcmp (argv[i], "-w") == 0) {
if (++i >= argc) Usage (argv[0]);
strcpy (output_name, argv[i]);
}
else if (strcmp (argv[i], "-I") == 0) {
if (++i >= argc) Usage (argv[0]);
idle_limit = (long)atoi(argv[i]);
}
else
Usage (argv[0]);
i++;
}
/* Open files */
if (strcmp(output_name, "") == 0)
outFP = stdout;
else
{
strcat(output_name, ".activity");
if ((outFP = fopen (output_name, "w")) == NULL) {
fprintf (stderr, "error opening %s\n", output_name);
exit (-1);
}
}
if (strcmp(input_name, "") == 0)
dumpFP = stdin;
else
{
if ((dumpFP = fopen (input_name, "r")) == NULL) {
fprintf (stderr, "error opening %s\n", input_name);
exit (-1);
}
}
/* Read each record in the input file. Look for a change in the
source IP address (which indicates a new client). If a new
client, log the end of an idle period (if any) for the old
client and initialize the connection table for the new client.
If a record for the current client has been read, classify the
type of event it represent and process it to update the client
and connection state.
*/
while (!feof (dumpFP)) {
/* Get and parse line of data */
if (fgets (new_line, sizeof(new_line), dumpFP) == NULL)
break;
/* get first line pieces */
sscanf (new_line, "%s %s %s %s %s %s %s",
&ts, &sh, &sp, >, &dh, &dp, &fl);
/* if an ERR line, just show it */
if (strcmp(fl, "ERR:") == 0)
{
error_line(new_line);
continue;
}
/* now get variable part starting with the ":" considering that */
/* interpretation of the remaining fields depends on the flag value */
/* This is necessary to find the ending timestamp for FIN, RST, and
TRM events.
*/
strcpy(parse_line, new_line);
cursor = parse_line;
vp = (char *)strsep(&cursor, ":" );
if ((cursor == (char *)NULL) ||
(vp == (char *)NULL))
{
error_line(new_line);
continue;
}
/* Classify the event type by looking at the flag field from input
records */
if ((strcmp(fl, "REQ") == 0) ||
(strcmp(fl, "REQ-") == 0))
event_type = REQ;
else
{
if ((strcmp(fl, "RSP") == 0) ||
(strcmp(fl, "RSP-") == 0))
event_type = RSP;
else
{
if ((strcmp(fl, "FIN") == 0) ||
(strcmp(fl, "TRM") == 0) ||
(strcmp(fl, "RST") == 0))
{
/* need the ending timestamp from these record types */
sscanf(cursor, "%s %s", &discard, &earliest_end);
event_type = END;
}
else
{
if (strcmp(fl, "SYN") == 0)
event_type = SYN;
else
{
if (strcmp(fl, "ACT-REQ") == 0)
event_type = ACT_REQ;
else
if (strcmp(fl, "ACT-RSP") == 0)
event_type = ACT_RSP;
}
}
}
}
/* now use data from new trace record to update status */
/* first check to see if this is the same client host */
if (strcmp(current_src, sh) != 0)
{
if (client_state == IDLE)
log_IDLE(last_client_ts);
ClearConnections();
client_state = PENDING_ACTIVE;
strcpy(current_src, sh);
}
/* update the connection status for this client's connection */
set_connection(sp, dh, dp, event_type);
/* The main processing for idle periods is done by maintaining a state
variable (client_status) for the client and looking for specific input
record types at different values of the state variable. The
values of client_state and their implications are:
PENDING_ACTIVE - A new client is started and remains PENDING_ACTIVE
until an activity indication such as ACT-REQ,
ACT-RSP, or REQ is seen in which case it enters
the ACTIVE state. If there is an initial response,
PENDING_IDLE is entered.
ACTIVE - At least one request is outstanding and the state
can only change if there is a response completion
or connection termination.
PENDING_IDLE - There are no requests outstanding but the idle
period threshold has not elapsed since it entered
the PENDING_IDLE state.
IDLE - No outstanding requests for a period greater than
the idle threshold. The IDLE (and PENDING_IDLE)
states are exited on activity indication such as
ACT-REQ, ACT-RSP, or REQ
*/
switch (client_state)
{
case PENDING_ACTIVE:
switch (event_type)
{
case SYN:
break;
case ACT_REQ:
case ACT_RSP:
client_state = ACTIVE;
break;
case REQ:
client_state = ACTIVE;
log_REQ();
break;
case RSP:
client_state = PENDING_IDLE;
strcpy(idle_begin, ts);
log_RSP();
break;
case END:
break;
}
break;
case ACTIVE:
switch (event_type)
{
case SYN:
case ACT_REQ:
case ACT_RSP:
break;
case REQ:
log_REQ();
break;
case RSP:
log_RSP();
if (ConnectionsActive() == 0) /* Any active connections?*/
{
client_state = PENDING_IDLE;
strcpy(idle_begin, ts);
}
break;
case END:
if (ConnectionsActive() == 0) /* Any active connections?*/
{
client_state = PENDING_IDLE;
strcpy(idle_begin, earliest_end);
}
break;
}
break;
case PENDING_IDLE:
/* must start checking time, if > n seconds elapse since
entering PENDING_IDLE state, enter IDLE state */
elapsed = elapsed_ms(ts, idle_begin);
if (elapsed < idle_limit)
{
switch (event_type)
{
case SYN:
case END:
break;
case ACT_REQ:
case ACT_RSP:
client_state = ACTIVE;
break;
case REQ:
client_state = ACTIVE;
log_REQ();
break;
case RSP:
log_RSP();
break;
}
break; /* ends case PENDING_IDLE */
}
else /* it has crossed the idle threshold */
client_state = IDLE;
/* NOTE: drop through to IDLE to handle the current event */
case IDLE:
switch (event_type)
{
case SYN:
case END:
break;
case ACT_REQ:
case ACT_RSP:
client_state = ACTIVE;
log_IDLE(ts);
break;
case REQ:
client_state = ACTIVE;
log_IDLE(ts);
log_REQ();
break;
case RSP:
log_RSP();
break;
break; /* ends case PENDING_IDLE */
}
break;
default:
break;
} /* end switch */
strcpy(last_client_ts, ts);
} /* end while (!feof ....) */
close (dumpFP);
close (outFP);
}
