/** Returns connection sequence (server indices), which must be freed */
static request_sequences perform_request(servers_fixture *f,
grpc_channel *client,
request_data *rdata,
const test_spec *spec) {
grpc_call *c;
int s_idx;
int *s_valid;
grpc_op ops[6];
grpc_op *op;
int was_cancelled;
size_t i, iter_num;
grpc_event ev;
int read_tag;
int completed_client;
const request_sequences sequences = request_sequences_create(spec->num_iters);
s_valid = gpr_malloc(sizeof(int) * f->num_servers);
for (iter_num = 0; iter_num < spec->num_iters; iter_num++) {
cq_verifier *cqv = cq_verifier_create(f->cq);
was_cancelled = 2;
for (i = 0; i < f->num_servers; i++) {
if (spec->kill_at[iter_num][i] != 0) {
kill_server(f, i);
} else if (spec->revive_at[iter_num][i] != 0) {
/* killing takes precedence */
revive_server(f, rdata, i);
}
}
sequences.connections[iter_num] = -1;
grpc_metadata_array_init(&rdata->initial_metadata_recv);
grpc_metadata_array_init(&rdata->trailing_metadata_recv);
for (i = 0; i < f->num_servers; i++) {
grpc_call_details_init(&rdata->call_details[i]);
}
memset(s_valid, 0, f->num_servers * sizeof(int));
grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
grpc_slice_from_static_string("/foo"), &host,
gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
GPR_ASSERT(c);
completed_client = 0;
memset(ops, 0, sizeof(ops));
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_INITIAL_METADATA;
op->data.recv_initial_metadata.recv_initial_metadata =
&rdata->initial_metadata_recv;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
op->data.recv_status_on_client.trailing_metadata =
&rdata->trailing_metadata_recv;
op->data.recv_status_on_client.status = &rdata->status;
op->data.recv_status_on_client.status_details = &rdata->details;
op->flags = 0;
op->reserved = NULL;
op++;
GPR_ASSERT(GRPC_CALL_OK ==
grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL));
s_idx = -1;
while (
(ev = grpc_completion_queue_next(
f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), NULL))
.type != GRPC_QUEUE_TIMEOUT) {
GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
read_tag = ((int)(intptr_t)ev.tag);
const grpc_connectivity_state conn_state =
grpc_channel_check_connectivity_state(client, 0);
sequences.connectivity_states[iter_num] = conn_state;
gpr_log(GPR_DEBUG, "EVENT: success:%d, type:%d, tag:%d iter:%" PRIuPTR,
ev.success, ev.type, read_tag, iter_num);
if (ev.success && read_tag >= 1000) {
GPR_ASSERT(s_idx == -1); /* only one server must reply */
/* only server notifications for non-shutdown events */
s_idx = read_tag - 1000;
s_valid[s_idx] = 1;
sequences.connections[iter_num] = s_idx;
break;
} else if (read_tag == 1) {
gpr_log(GPR_DEBUG, "client timed out");
GPR_ASSERT(ev.success);
completed_client = 1;
}
}
if (s_idx >= 0) {
memset(ops, 0, sizeof(ops));
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
grpc_slice status_details = grpc_slice_from_static_string("xyz");
op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
op->data.recv_close_on_server.cancelled = &was_cancelled;
op->flags = 0;
op->reserved = NULL;
op++;
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(f->server_calls[s_idx],
ops, (size_t)(op - ops),
tag(102), NULL));
CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
if (!completed_client) {
CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
}
cq_verify(cqv);
GPR_ASSERT(rdata->status == GRPC_STATUS_UNIMPLEMENTED);
GPR_ASSERT(0 == grpc_slice_str_cmp(rdata->details, "xyz"));
GPR_ASSERT(0 ==
grpc_slice_str_cmp(rdata->call_details[s_idx].method, "/foo"));
GPR_ASSERT(0 == grpc_slice_str_cmp(rdata->call_details[s_idx].host,
"foo.test.google.fr"));
GPR_ASSERT(was_cancelled == 1);
grpc_call_destroy(f->server_calls[s_idx]);
/* ask for the next request on this server */
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
f->servers[s_idx], &f->server_calls[s_idx],
&rdata->call_details[s_idx],
&f->request_metadata_recv[s_idx], f->cq,
f->cq, tag(1000 + (int)s_idx)));
} else { /* no response from server */
grpc_call_cancel(c, NULL);
if (!completed_client) {
CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
cq_verify(cqv);
}
}
GPR_ASSERT(
grpc_completion_queue_next(
f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), NULL)
.type == GRPC_QUEUE_TIMEOUT);
grpc_metadata_array_destroy(&rdata->initial_metadata_recv);
grpc_metadata_array_destroy(&rdata->trailing_metadata_recv);
cq_verifier_destroy(cqv);
grpc_call_destroy(c);
for (i = 0; i < f->num_servers; i++) {
grpc_call_details_destroy(&rdata->call_details[i]);
}
grpc_slice_unref(rdata->details);
}
gpr_free(s_valid);
return sequences;
}
void cbm_iec_device::set_signal(device_t *device, int signal, int state)
{
bool changed = false;
if (device == this)
{
if (m_line[signal] != state)
{
if (LOG) logerror("CBM IEC: '%s' %s %u\n", tag(), SIGNAL_NAME[signal], state);
m_line[signal] = state;
changed = true;
}
}
else
{
daisy_entry *entry = m_device_list.first();
while (entry)
{
if (!strcmp(entry->m_device->tag(), device->tag()))
{
if (entry->m_line[signal] != state)
{
if (LOG) logerror("CBM IEC: '%s' %s %u\n", device->tag(), SIGNAL_NAME[signal], state);
entry->m_line[signal] = state;
changed = true;
}
}
entry = entry->next();
}
}
if (changed)
{
switch (signal)
{
case SRQ: m_write_srq(state); break;
case ATN: m_write_atn(state); break;
case CLK: m_write_clk(state); break;
case DATA: m_write_data(state); break;
case RESET: m_write_reset(state);break;
}
daisy_entry *entry = m_device_list.first();
while (entry)
{
switch (signal)
{
case SRQ:
entry->m_interface->cbm_iec_srq(state);
break;
case ATN:
entry->m_interface->cbm_iec_atn(state);
break;
case CLK:
entry->m_interface->cbm_iec_clk(state);
break;
case DATA:
entry->m_interface->cbm_iec_data(state);
break;
case RESET:
entry->m_interface->cbm_iec_reset(state);
break;
}
entry = entry->next();
}
if (LOG) logerror("CBM IEC: SRQ %u ATN %u CLK %u DATA %u RESET %u\n",
get_signal(SRQ), get_signal(ATN), get_signal(CLK), get_signal(DATA), get_signal(RESET));
}
}
void nsc810_device::write(offs_t offset, uint8_t data)
{
uint32_t rate;
if(m_ramselect)
{
// TODO: 128 byte RAM access
}
else
{
// Register access
switch(offset & 0x1f)
{
case REG_PORTA:
m_portA_latch = data & ~m_ddrA;
m_portA_w((0xff & ~m_ddrA) | (data & m_ddrA));
LOG("NSC810: Port A data write %02x\n",data);
break;
case REG_PORTB:
m_portB_latch = data & ~m_ddrB;
m_portB_w((0xff & ~m_ddrB) | (data & m_ddrB));
LOG("NSC810: Port B data write %02x\n",data);
break;
case REG_PORTC:
m_portC_latch = data & ~m_ddrC;
m_portC_w((0xff & ~m_ddrC) | (data & m_ddrC));
LOG("NSC810: Port C data write %02x\n",data);
break;
case REG_DDRA:
m_ddrA = data;
LOG("NSC810: Port A direction write %02x\n",data);
break;
case REG_DDRB:
m_ddrB = data;
LOG("NSC810: Port B direction write %02x\n",data);
break;
case REG_DDRC:
m_ddrC = data;
LOG("NSC810: Port C direction write %02x\n",data);
break;
case REG_MODE_DEF:
LOG("NSC810: Mode Definition write %02x\n",data);
break;
case REG_PORTA_BITCLR:
LOG("NSC810: Port A bit-clear write %02x\n",data);
break;
case REG_PORTB_BITCLR:
LOG("NSC810: Port B bit-clear write %02x\n",data);
break;
case REG_PORTC_BITCLR:
LOG("NSC810: Port C bit-clear write %02x\n",data);
break;
case REG_PORTA_BITSET:
LOG("NSC810: Port A bit-set write %02x\n",data);
break;
case REG_PORTB_BITSET:
LOG("NSC810: Port B bit-set write %02x\n",data);
break;
case REG_PORTC_BITSET:
LOG("NSC810: Port C bit-set write %02x\n",data);
break;
case REG_TIMER0_LOW:
m_timer0_base = (m_timer0_base & 0xff00) | data;
m_timer0_counter = (m_timer0_counter & 0xff00) | data;
LOG("NSC810: Timer 0 low-byte write %02x (base=%04x)\n",data,m_timer0_base);
break;
case REG_TIMER0_HIGH:
m_timer0_base = (m_timer0_base & 0x00ff) | (data << 8);
m_timer0_counter = (m_timer0_counter & 0x00ff) | (data << 8);
LOG("NSC810: Timer 0 high-byte write %02x (base=%04x)\n",data,m_timer0_base);
break;
case REG_TIMER1_LOW:
m_timer1_base = (m_timer1_base & 0xff00) | data;
m_timer1_counter = (m_timer1_counter & 0xff00) | data;
LOG("NSC810: Timer 1 low-byte write %02x (base=%04x)\n",data,m_timer1_base);
break;
case REG_TIMER1_HIGH:
m_timer1_base = (m_timer1_base & 0x00ff) | (data << 8);
m_timer1_counter = (m_timer1_counter & 0x00ff) | (data << 8);
LOG("NSC810: Timer 1 high-byte write %02x (base=%04x)\n",data,m_timer1_base);
break;
case REG_TIMER0_STOP:
m_timer0_running = false;
m_timer0->reset();
LOG("NSC810: Timer 0 Stop write %02x\n",tag(),data);
break;
case REG_TIMER0_START:
if((m_timer0_mode & 0x07) != 0x00 && (m_timer0_mode & 0x07) != 0x07)
{
m_timer0_running = true;
if(m_timer0_mode & 0x10)
rate = m_timer0_clock / 64;
else
if(m_timer0_mode & 0x08)
rate = m_timer0_clock / 2;
else
rate = m_timer0_clock;
m_timer0->adjust(attotime::zero,0,attotime::from_hz(rate));
}
LOG("NSC810: Timer 0 Start write %02x\n",data);
break;
case REG_TIMER1_STOP:
m_timer1_running = false;
m_timer1->reset();
LOG("NSC810: Timer 1 Stop write %02x\n",data);
break;
case REG_TIMER1_START:
if((m_timer1_mode & 0x07) != 0x00 && (m_timer1_mode & 0x07) != 0x07)
{
m_timer1_running = true;
// no /64 prescaler on timer 1
if(m_timer0_mode & 0x08)
rate = m_timer0_clock / 2;
else
rate = m_timer0_clock;
m_timer1->adjust(attotime::zero,0,attotime::from_hz(rate));
}
LOG("NSC810: Timer 1 Start write %02x\n",data);
break;
case REG_MODE_TIMER0:
m_timer0_mode = data;
LOG("NSC810: Timer 0 Mode write %02x\n",data);
break;
case REG_MODE_TIMER1:
m_timer1_mode = data;
LOG("NSC810: Timer 1 Mode write %02x\n",data);
break;
default:
logerror("NSC810: Unused register %02x write %02x\n",offset,data);
}
}
}
static void test_early_server_shutdown_finishes_inflight_calls(
grpc_end2end_test_config config) {
grpc_call *c;
grpc_call *s;
gpr_timespec deadline = n_seconds_time(10);
grpc_end2end_test_fixture f = begin_test(
config, "test_early_server_shutdown_finishes_inflight_calls", NULL, NULL);
cq_verifier *cqv = cq_verifier_create(f.cq);
grpc_op ops[6];
grpc_op *op;
grpc_metadata_array initial_metadata_recv;
grpc_metadata_array trailing_metadata_recv;
grpc_metadata_array request_metadata_recv;
grpc_call_details call_details;
grpc_status_code status;
grpc_call_error error;
char *details = NULL;
size_t details_capacity = 0;
int was_cancelled = 2;
c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
"/foo", "foo.test.google.fr", deadline, NULL);
GPR_ASSERT(c);
grpc_metadata_array_init(&initial_metadata_recv);
grpc_metadata_array_init(&trailing_metadata_recv);
grpc_metadata_array_init(&request_metadata_recv);
grpc_call_details_init(&call_details);
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->data.send_initial_metadata.metadata = NULL;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_INITIAL_METADATA;
op->data.recv_initial_metadata = &initial_metadata_recv;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL);
GPR_ASSERT(GRPC_CALL_OK == error);
error =
grpc_server_request_call(f.server, &s, &call_details,
&request_metadata_recv, f.cq, f.cq, tag(101));
GPR_ASSERT(GRPC_CALL_OK == error);
cq_expect_completion(cqv, tag(101), 1);
cq_verify(cqv);
/* shutdown and destroy the server */
grpc_server_shutdown_and_notify(f.server, f.cq, tag(0xdead));
cq_verify_empty(cqv);
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
op->data.send_status_from_server.status_details = "xyz";
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
op->data.recv_close_on_server.cancelled = &was_cancelled;
op->flags = 0;
op->reserved = NULL;
op++;
error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL);
GPR_ASSERT(GRPC_CALL_OK == error);
cq_expect_completion(cqv, tag(102), 1);
cq_expect_completion(cqv, tag(0xdead), 1);
cq_expect_completion(cqv, tag(1), 1);
cq_verify(cqv);
grpc_call_destroy(s);
GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED);
GPR_ASSERT(0 == strcmp(call_details.method, "/foo"));
GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr"));
GPR_ASSERT(was_cancelled == 1);
gpr_free(details);
grpc_metadata_array_destroy(&initial_metadata_recv);
grpc_metadata_array_destroy(&trailing_metadata_recv);
grpc_metadata_array_destroy(&request_metadata_recv);
grpc_call_details_destroy(&call_details);
grpc_call_destroy(c);
cq_verifier_destroy(cqv);
end_test(&f);
config.tear_down_data(&f);
}
/*
* TIACK* provides the Timer vector in an iack cycle
*/
uint8_t pit68230_device::irq_tiack()
{
LOGINT("%s %s <- %02x\n",tag(), FUNCNAME, m_tivr);
return m_tivr;
}
void vp550_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
if (LOG) logerror("VP550 '%s' Interrupt\n", tag());
m_slot->interrupt_w(ASSERT_LINE);
}
/* Client sends a request with payload, server reads then returns status. */
static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
grpc_call *c;
grpc_call *s;
gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
grpc_byte_buffer *request_payload =
grpc_byte_buffer_create(&request_payload_slice, 1);
gpr_timespec deadline = five_seconds_time();
grpc_end2end_test_fixture f = begin_test(config, __FUNCTION__, NULL, NULL);
cq_verifier *v_client = cq_verifier_create(f.client_cq);
cq_verifier *v_server = cq_verifier_create(f.server_cq);
grpc_op ops[6];
grpc_op *op;
grpc_metadata_array initial_metadata_recv;
grpc_metadata_array trailing_metadata_recv;
grpc_metadata_array request_metadata_recv;
grpc_byte_buffer *request_payload_recv = NULL;
grpc_call_details call_details;
grpc_status_code status;
char *details = NULL;
size_t details_capacity = 0;
int was_cancelled = 2;
c = grpc_channel_create_call(f.client, f.client_cq, "/foo",
"foo.test.google.fr", deadline);
GPR_ASSERT(c);
grpc_metadata_array_init(&initial_metadata_recv);
grpc_metadata_array_init(&trailing_metadata_recv);
grpc_metadata_array_init(&request_metadata_recv);
grpc_call_details_init(&call_details);
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op++;
op->op = GRPC_OP_SEND_MESSAGE;
op->data.send_message = request_payload;
op++;
op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
op++;
op->op = GRPC_OP_RECV_INITIAL_METADATA;
op->data.recv_initial_metadata = &initial_metadata_recv;
op++;
op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op++;
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, ops, op - ops, tag(1)));
GPR_ASSERT(GRPC_CALL_OK ==
grpc_server_request_call(f.server, &s, &call_details,
&request_metadata_recv, f.server_cq,
f.server_cq, tag(101)));
cq_expect_completion(v_server, tag(101), GRPC_OP_OK);
cq_verify(v_server);
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op++;
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_OK;
op->data.send_status_from_server.status_details = "xyz";
op++;
op->op = GRPC_OP_RECV_MESSAGE;
op->data.recv_message = &request_payload_recv;
op++;
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
op->data.recv_close_on_server.cancelled = &was_cancelled;
op++;
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(s, ops, op - ops, tag(102)));
cq_expect_completion(v_server, tag(102), GRPC_OP_OK);
cq_verify(v_server);
cq_expect_completion(v_client, tag(1), GRPC_OP_OK);
cq_verify(v_client);
GPR_ASSERT(status == GRPC_STATUS_OK);
GPR_ASSERT(0 == strcmp(details, "xyz"));
GPR_ASSERT(0 == strcmp(call_details.method, "/foo"));
GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr"));
GPR_ASSERT(was_cancelled == 0);
GPR_ASSERT(byte_buffer_eq_string(request_payload_recv, "hello world"));
gpr_free(details);
grpc_metadata_array_destroy(&initial_metadata_recv);
grpc_metadata_array_destroy(&trailing_metadata_recv);
grpc_metadata_array_destroy(&request_metadata_recv);
grpc_call_details_destroy(&call_details);
grpc_call_destroy(c);
grpc_call_destroy(s);
cq_verifier_destroy(v_client);
cq_verifier_destroy(v_server);
grpc_byte_buffer_destroy(request_payload);
grpc_byte_buffer_destroy(request_payload_recv);
end_test(&f);
config.tear_down_data(&f);
}
void pit68230_device::wr_pitreg_cprh(uint8_t data)
{
LOG("%s(%02x) \"%s\": %s - %02x\n", FUNCNAME, data, tag(), FUNCNAME, data);
m_cpr &= ~0xff0000;
m_cpr |= ((data << 16) & 0xff0000);
}
void pit68230_device::wr_pitreg_cprl(uint8_t data)
{
LOG("%s(%02x) \"%s\": %s - %02x\n", FUNCNAME, data, tag(), FUNCNAME, data);
m_cpr &= ~0x0000ff;
m_cpr |= ((data << 0) & 0x0000ff);
}
void pit68230_device::wr_pitreg_psr(uint8_t data)
{
LOG("%s(%02x) \"%s\": %s - %02x\n", FUNCNAME, data, tag(), FUNCNAME, data);
m_psr = data;
}
void pit68230_device::wr_pitreg_tivr(uint8_t data)
{
LOG("%s(%02x) \"%s\": \n", FUNCNAME, data, tag());
m_tivr = data;
}
void pit68230_device::wr_pitreg_pivr(uint8_t data)
{
LOG("%s(%02x) \"%s\": Not implemented yet\n", FUNCNAME, data, tag());
}
void pit68230_device::wr_pitreg_pcddr(uint8_t data)
{
LOG("%s(%02x) \"%s\": %s - %02x\n", FUNCNAME, data, tag(), FUNCNAME, data);
LOGSETUP("%s PCDDR: %02x\n", tag(), data);
m_pcddr = data;
}
void pit68230_device::wr_pitreg_pbddr(uint8_t data)
{
LOGSETUP("%s PBDDR: %02x\n", tag(), data);
m_pbddr = data;
}
int main(int argc, char **argv) {
grpc_channel *chan;
grpc_call *call;
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(2);
grpc_completion_queue *cq;
cq_verifier *cqv;
grpc_op ops[6];
grpc_op *op;
grpc_metadata_array trailing_metadata_recv;
grpc_status_code status;
char *details = NULL;
size_t details_capacity = 0;
grpc_test_init(argc, argv);
grpc_init();
grpc_metadata_array_init(&trailing_metadata_recv);
cq = grpc_completion_queue_create(NULL);
cqv = cq_verifier_create(cq);
/* create a call, channel to a non existant server */
chan = grpc_insecure_channel_create("nonexistant:54321", NULL, NULL);
call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
"/Foo", "nonexistant", deadline, NULL);
memset(ops, 0, sizeof(ops));
op = ops;
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(
call, ops, (size_t)(op - ops), tag(1), NULL));
/* verify that all tags get completed */
cq_expect_completion(cqv, tag(1), 1);
cq_verify(cqv);
GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED);
grpc_completion_queue_shutdown(cq);
while (
grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL)
.type != GRPC_QUEUE_SHUTDOWN)
;
grpc_completion_queue_destroy(cq);
grpc_call_destroy(call);
grpc_channel_destroy(chan);
cq_verifier_destroy(cqv);
gpr_free(details);
grpc_metadata_array_destroy(&trailing_metadata_recv);
grpc_shutdown();
return 0;
}
uint8_t pit68230_device::rr_pitreg_psrr()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, m_psrr);
return m_psrr & 0x7f; // mask out unused bits
}
void at29040a_device::device_reset(void)
{
if (m_eememory[0] != VERSION)
{
if (VERBOSE>1) LOG("AT29040A: Warning: Version mismatch; expected %d but found %d for %s. Resetting.\n", VERSION, m_eememory[0], tag());
m_eememory[0] = 0;
m_eememory[1] = 0;
}
m_lower_bbl = ((m_eememory[1] & 0x04)!=0);
m_higher_bbl = ((m_eememory[1] & 0x02)!=0);
m_sdp = ((m_eememory[1] & 0x01)!=0);
if (VERBOSE>7) LOG("at29040a (%s): LowerBBL = %d, HigherBBL = %d, SoftDataProt = %d\n", tag(), m_lower_bbl, m_higher_bbl, m_sdp);
m_id_mode = false;
m_cmd = CMD_0;
m_enabling_bbl = false;
m_long_sequence = false;
m_pgm = PGM_0;
m_enabling_sdb = false;
m_disabling_sdb = false;
m_toggle_bit = false;
m_programming_last_offset = 0;
}
uint8_t pit68230_device::rr_pitreg_tivr()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, m_tivr);
return m_tivr;
}
/*---------------------------------------------------------------------------
* AddAggregate
* Add XML Aggregate start tag. You can specify attributes here, if any.
*
*/
void DOMXMLBuilder::AddAggregate(const string &inputTag,
const string attNameArray[],
const string attValueArray[],
int attCount)
{
HRESULT hr;
CComBSTR tag(inputTag.c_str());
// new element
MSXML2::IXMLDOMElement *newElement = NULL;
MSXML2::IXMLDOMNode *tmpNode = NULL;
// Instantiate MSXML if we haven't already
if (m_XMLDoc == NULL) {
if (!InstantiateXMLDomDocument()) {
return;
}
}
// Create a new element
hr = m_XMLDoc ->createElement(tag.m_str, &newElement);
if (FAILED(hr)) { // failed
m_HasError = true;
m_ErrorMsg = "createElement for new aggregate failed";
return;
}
if (m_IsTopLevel) {
m_IsTopLevel = false;
// append this new node to the document root
hr = m_XMLDoc ->appendChild(newElement, &tmpNode);
}
else {
// append this new node to the current node
hr = m_CurrentNode ->appendChild(newElement, &tmpNode);
}
if (FAILED(hr)) { // failed
m_HasError = true;
m_ErrorMsg = "appendChild for new aggregate failed";
newElement ->Release();
return;
}
// We don't need the tmpNode that appendChild returns.
tmpNode ->Release();
// set current node
if (m_CurrentNode != NULL) {
m_CurrentNode ->Release();
}
m_CurrentNode = newElement;
// set attribute list here
for (int i = 0; i < attCount; ++i) {
CComBSTR name(attNameArray[i].c_str());
_variant_t value(attValueArray[i].c_str()); // VARIANT
hr = newElement ->setAttribute(name.m_str, value);
if (FAILED(hr)) {
m_HasError = true;
m_ErrorMsg = "setAttribute on new aggregate failed";
return;
}
}
}
int main(int argc, char **argv) {
grpc_event ev;
call_state *s;
char *addr_buf = NULL;
gpr_cmdline *cl;
int shutdown_started = 0;
int shutdown_finished = 0;
int secure = 0;
char *addr = NULL;
char *fake_argv[1];
gpr_timers_set_log_filename("latency_trace.fling_server.txt");
GPR_ASSERT(argc >= 1);
fake_argv[0] = argv[0];
grpc_test_init(1, fake_argv);
grpc_init();
srand((unsigned)clock());
cl = gpr_cmdline_create("fling server");
gpr_cmdline_add_string(cl, "bind", "Bind host:port", &addr);
gpr_cmdline_add_flag(cl, "secure", "Run with security?", &secure);
gpr_cmdline_parse(cl, argc, argv);
gpr_cmdline_destroy(cl);
if (addr == NULL) {
gpr_join_host_port(&addr_buf, "::", grpc_pick_unused_port_or_die());
addr = addr_buf;
}
gpr_log(GPR_INFO, "creating server on: %s", addr);
cq = grpc_completion_queue_create(NULL);
if (secure) {
grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
test_server1_cert};
grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(
NULL, &pem_key_cert_pair, 1, 0, NULL);
server = grpc_server_create(NULL, NULL);
GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
grpc_server_credentials_release(ssl_creds);
} else {
server = grpc_server_create(NULL, NULL);
GPR_ASSERT(grpc_server_add_insecure_http2_port(server, addr));
}
grpc_server_register_completion_queue(server, cq, NULL);
grpc_server_start(server);
gpr_free(addr_buf);
addr = addr_buf = NULL;
grpc_call_details_init(&call_details);
request_call();
grpc_profiler_start("server.prof");
signal(SIGINT, sigint_handler);
while (!shutdown_finished) {
if (got_sigint && !shutdown_started) {
gpr_log(GPR_INFO, "Shutting down due to SIGINT");
grpc_server_shutdown_and_notify(server, cq, tag(1000));
GPR_ASSERT(grpc_completion_queue_pluck(
cq, tag(1000), GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), NULL)
.type == GRPC_OP_COMPLETE);
grpc_completion_queue_shutdown(cq);
shutdown_started = 1;
}
ev = grpc_completion_queue_next(
cq, gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_micros(1000000, GPR_TIMESPAN)),
NULL);
s = ev.tag;
switch (ev.type) {
case GRPC_OP_COMPLETE:
switch ((intptr_t)s) {
case FLING_SERVER_NEW_REQUEST:
if (call != NULL) {
if (0 ==
strcmp(call_details.method, "/Reflector/reflectStream")) {
/* Received streaming call. Send metadata here. */
start_read_op(FLING_SERVER_READ_FOR_STREAMING);
send_initial_metadata();
} else {
/* Received unary call. Can do all ops in one batch. */
start_read_op(FLING_SERVER_READ_FOR_UNARY);
}
} else {
GPR_ASSERT(shutdown_started);
}
/* request_call();
*/
break;
case FLING_SERVER_READ_FOR_STREAMING:
if (payload_buffer != NULL) {
/* Received payload from client. */
start_write_op();
} else {
/* Received end of stream from client. */
start_send_status();
}
break;
case FLING_SERVER_WRITE_FOR_STREAMING:
/* Write completed at server */
grpc_byte_buffer_destroy(payload_buffer);
payload_buffer = NULL;
start_read_op(FLING_SERVER_READ_FOR_STREAMING);
break;
case FLING_SERVER_SEND_INIT_METADATA_FOR_STREAMING:
/* Metadata send completed at server */
break;
case FLING_SERVER_SEND_STATUS_FOR_STREAMING:
/* Send status and close completed at server */
grpc_call_destroy(call);
if (!shutdown_started) request_call();
break;
case FLING_SERVER_READ_FOR_UNARY:
/* Finished payload read for unary. Start all reamaining
* unary ops in a batch.
*/
handle_unary_method();
break;
case FLING_SERVER_BATCH_OPS_FOR_UNARY:
/* Finished unary call. */
grpc_byte_buffer_destroy(payload_buffer);
payload_buffer = NULL;
grpc_call_destroy(call);
if (!shutdown_started) request_call();
break;
}
break;
case GRPC_QUEUE_SHUTDOWN:
GPR_ASSERT(shutdown_started);
shutdown_finished = 1;
break;
case GRPC_QUEUE_TIMEOUT:
break;
}
}
grpc_profiler_stop();
grpc_call_details_destroy(&call_details);
grpc_server_destroy(server);
grpc_completion_queue_destroy(cq);
grpc_shutdown();
return 0;
}
void okim6295_device::write_command(UINT8 command)
{
// if a command is pending, process the second half
if (m_command != -1)
{
// the manual explicitly says that it's not possible to start multiple voices at the same time
int voicemask = command >> 4;
//if (voicemask != 0 && voicemask != 1 && voicemask != 2 && voicemask != 4 && voicemask != 8)
// popmessage("OKI6295 start %x contact MAMEDEV", voicemask);
// update the stream
m_stream->update();
// determine which voice(s) (voice is set by a 1 bit in the upper 4 bits of the second byte)
for (int voicenum = 0; voicenum < OKIM6295_VOICES; voicenum++, voicemask >>= 1)
if (voicemask & 1)
{
okim_voice &voice = m_voice[voicenum];
if (!voice.m_playing) // fixes Got-cha and Steel Force
{
// determine the start/stop positions
offs_t base = m_command * 8;
offs_t start = m_direct->read_raw_byte(base + 0) << 16;
start |= m_direct->read_raw_byte(base + 1) << 8;
start |= m_direct->read_raw_byte(base + 2) << 0;
start &= 0x3ffff;
offs_t stop = m_direct->read_raw_byte(base + 3) << 16;
stop |= m_direct->read_raw_byte(base + 4) << 8;
stop |= m_direct->read_raw_byte(base + 5) << 0;
stop &= 0x3ffff;
if (start < stop)
{
// set up the voice to play this sample
voice.m_playing = true;
voice.m_base_offset = start;
voice.m_sample = 0;
voice.m_count = 2 * (stop - start + 1);
// also reset the ADPCM parameters
voice.m_adpcm.reset();
voice.m_volume = s_volume_table[command & 0x0f];
}
// invalid samples go here
else
{
logerror("OKIM6295:'%s' requested to play invalid sample %02x\n",tag(),m_command);
}
}
else
{
logerror("OKIM6295:'%s' requested to play sample %02x on non-stopped voice\n",tag(),m_command);
}
}
// reset the command
m_command = -1;
}
static void request_call(void) {
grpc_metadata_array_init(&request_metadata_recv);
grpc_server_request_call(server, &call, &call_details, &request_metadata_recv,
cq, cq, tag(FLING_SERVER_NEW_REQUEST));
}
static int
mark_for_copy(Word p, int flags ARG_LD)
{ Word start = p;
int walk_ref = FALSE;
Word buf[1024];
segstack stack;
initSegStack(&stack, sizeof(Word), sizeof(buf), buf);
for(;;)
{ switch(tag(*p))
{ case TAG_ATTVAR:
{ if ( flags & COPY_ATTRS )
{ if ( !pushForMark(&stack, p, walk_ref) )
{ clearSegStack(&stack);
return MEMORY_OVERFLOW;
}
walk_ref = TRUE;
p = valPAttVar(*p);
continue;
}
/*FALLTHROUGH*/
}
case TAG_VAR:
{ if ( virgin(*p) )
set_visited(*p);
else if ( visited_once(*p) )
set_shared(*p);
break;
}
case TAG_REFERENCE:
{ if ( !pushForMark(&stack, p, walk_ref) )
{ clearSegStack(&stack);
return MEMORY_OVERFLOW;
}
walk_ref = TRUE;
deRef(p);
continue;
}
case TAG_COMPOUND:
{ Functor t = valueTerm(*p);
int arity = arityFunctor(t->definition);
if ( virgin(t->definition) )
{ set_visited(t->definition);
} else
{ if ( visited_once(t->definition) )
set_shared(t->definition);
break;
}
if ( arity >= 1 )
{ if ( !pushForMark(&stack, p, walk_ref) )
{ clearSegStack(&stack);
return MEMORY_OVERFLOW;
}
walk_ref = FALSE;
p = &t->arguments[arity-1]; /* last argument */
continue;
}
}
}
if ( p == start )
{ clearSegStack(&stack);
return TRUE;
}
while ( walk_ref )
{ popForMark(&stack, &p, &walk_ref);
if ( isAttVar(*p) )
{ Word ap = valPAttVar(*p);
unshare_attvar(ap PASS_LD);
}
if ( p == start )
{ clearSegStack(&stack);
return TRUE;
}
}
p--;
if ( tagex(*p) == (TAG_ATOM|STG_GLOBAL) )
{ popForMark(&stack, &p, &walk_ref);
update_ground(p PASS_LD);
}
}
}
uint8_t pit68230_device::rr_pitreg_tcr()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, m_tcr);
return m_tcr;
}
uint8_t pit68230_device::rr_pitreg_tivr()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, m_tivr);
return m_tivr;
}
uint8_t pit68230_device::rr_pitreg_cprh()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, (m_cpr >> 16) & 0xff);
return (m_cpr >> 16) & 0xff;
}
uint8_t pit68230_device::rr_pitreg_cprm()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, (m_cpr >> 8) & 0xff);
return (m_cpr >> 8) & 0xff;
}
uint8_t pit68230_device::rr_pitreg_cprl()
{
LOGR("%s %s <- %02x\n",tag(), FUNCNAME, (m_cpr >> 0) & 0xff);
return (m_cpr >> 0) & 0xff;
}
