static void
_benchmark(ssize_t write_size)
{
ssize_t res;
int write_count = 0;
float secs;
alarm_notice = 0;
alarm (10);
qb_util_stopwatch_start(sw);
do {
res = qb_rb_chunk_write(rb, buffer, write_size);
if (res == write_size) {
write_count++;
}
} while (alarm_notice == 0 && (res == write_size || res == -EAGAIN));
if (res < 0) {
perror("qb_ipcc_sendv");
}
qb_util_stopwatch_stop(sw);
secs = qb_util_stopwatch_sec_elapsed_get(sw);
printf ("%5d messages sent ", write_count);
printf ("%5ld bytes per write ", (long int) write_size);
printf ("%7.3f Seconds runtime ", secs);
printf ("%9.3f TP/s ",
((float)write_count) / secs);
printf ("%7.3f MB/s.\n",
((float)write_count) * ((float)write_size) / secs);
}
static void bm_finish(struct bm_ctx *ctx, const char *operation, int32_t size)
{
qb_util_stopwatch_stop(ctx->sw);
ctx->secs = qb_util_stopwatch_sec_elapsed_get(ctx->sw);
ctx->mbs =
((((float)ctx->counter) * size) / ctx->secs) / (1024.0 *
1024.0);
}
static void resource_execute_cb(struct pe_operation *op)
{
struct resource *resource;
struct assembly *assembly;
qb_enter();
assembly = qb_map_get(assembly_map, op->hostname);
resource = qb_map_get(assembly->resource_map, op->rname);
if (assembly->recover.state != RECOVER_STATE_RUNNING) {
qb_log(LOG_DEBUG, "can't execute resource in offline state");
resource_action_completed(op, OCF_UNKNOWN_ERROR);
return;
}
qb_log(LOG_TRACE, "%s_%s_%d [%s] on %s target_rc:%d",
op->rname, op->method, op->interval, op->rclass, op->hostname,
op->target_outcome);
qb_util_stopwatch_start(op->time_execed);
op->resource = resource;
if (strcmp(op->method, "monitor") == 0) {
if (strstr(op->rname, op->hostname) != NULL) {
assert(op->resource);
if (op->interval > 0) {
recurring_monitor_start(op);
} else {
resource_monitor_execute(op);
}
} else {
qb_util_stopwatch_stop(op->time_execed);
pe_resource_completed(op, OCF_NOT_RUNNING);
pe_resource_unref(op);
}
} else if (strcmp (op->method, "start") == 0) {
transport_resource_action(assembly, resource, op);
} else if (strcmp(op->method, "stop") == 0) {
if (resource->monitor_op) {
recurring_monitor_stop(resource->monitor_op);
}
transport_resource_action(assembly, resource, op);
} else if (strcmp(op->method, "delete") == 0) {
op_history_delete(op);
} else {
assert(0);
}
qb_leave();
}
static void recurring_monitor_start(struct pe_operation *op)
{
struct resource * r = (struct resource *)op->resource;
if (!qb_loop_timer_is_running(NULL, r->monitor_timer)) {
pe_resource_ref(op);
r->monitor_op = op;
resource_monitor_execute(op);
} else {
qb_util_stopwatch_stop(op->time_execed);
pe_resource_completed(op, OCF_OK);
pe_resource_unref(op);
}
}
void
resource_action_completed(struct pe_operation *op,
enum ocf_exitcode pe_exitcode)
{
uint64_t el;
struct assembly *a = qb_map_get(assembly_map, op->hostname);;
struct resource *r = qb_map_get(a->resource_map, op->rname);
qb_enter();
op->times_executed++;
qb_util_stopwatch_stop(op->time_execed);
el = qb_util_stopwatch_us_elapsed_get(op->time_execed);
qb_log(LOG_INFO, "%s_%s_%d [%s] on %s rc:[%d/%d] time:[%"PRIu64"/%ums]",
op->rname, op->method, op->interval, op->rclass, op->hostname,
pe_exitcode, op->target_outcome,
el / QB_TIME_US_IN_MSEC, op->timeout);
if (strstr(op->rname, op->hostname) != NULL) {
op_history_save(r, op, pe_exitcode);
}
if (op->times_executed <= 1) {
pe_resource_completed(op, pe_exitcode);
}
resource_state_set(r, op, pe_exitcode);
if (pe_exitcode != op->target_outcome) {
schedule_processing();
}
if (op->interval > 0) {
if (pe_exitcode != op->target_outcome) {
/* unreference as not used by the timer anymore.
*/
pe_resource_unref(op);
} else {
qb_loop_timer_add(NULL, QB_LOOP_LOW,
op->interval * QB_TIME_NS_IN_MSEC, op,
resource_monitor_execute,
&r->monitor_timer);
}
} else {
pe_resource_unref(op);
}
qb_leave();
}
static void job_add_self(void *data)
{
int32_t res;
uint64_t elapsed1;
qb_loop_t *l = (qb_loop_t *)data;
job_1_run_count++;
qb_util_stopwatch_stop(rl_sw);
elapsed1 = qb_util_stopwatch_us_elapsed_get(rl_sw);
if (elapsed1 > (RATE_LIMIT_RUNTIME_SEC * QB_TIME_US_IN_SEC)) {
/* run for 3 seconds */
qb_loop_stop(l);
return;
}
res = qb_loop_job_add(l, QB_LOOP_MED, data, job_add_self);
ck_assert_int_eq(res, 0);
}
static void instance_state_completion(char *state, char *address, void *data)
{
struct assembly *assembly = (struct assembly *)data;
if (strcmp(state, "ACTIVE") == 0) {
assembly->address = strdup(address);
qb_util_stopwatch_stop(assembly->sw_instance_create);
qb_log(LOG_INFO, "Instance '%s' with address '%s' changed to RUNNING in (%lld ms).",
assembly->name, assembly->address,
qb_util_stopwatch_us_elapsed_get(assembly->sw_instance_create) / 1000);
qb_util_stopwatch_start(assembly->sw_instance_connected);
transport_connect(assembly);
} else {
recover_state_set(&assembly->recover, RECOVER_STATE_UNKNOWN);
qb_loop_timer_add(NULL, QB_LOOP_LOW,
PENDING_TIMEOUT * QB_TIME_NS_IN_MSEC, assembly,
my_instance_state_get, NULL);
}
}
static void
_benchmark(qb_ipcc_connection_t *conn, int write_size)
{
struct iovec iov[2];
ssize_t res;
struct qb_ipc_request_header hdr;
int write_count = 0;
float secs;
alarm_notice = 0;
hdr.size = write_size;
hdr.id = QB_IPC_MSG_USER_START + 1;
iov[0].iov_base = &hdr;
iov[0].iov_len = sizeof(struct qb_ipc_request_header);
iov[1].iov_base = data;
iov[1].iov_len = write_size - sizeof(struct qb_ipc_request_header);
alarm (10);
qb_util_stopwatch_start(sw);
do {
res = qb_ipcc_sendv(conn, iov, 2);
if (res == write_size) {
write_count++;
}
} while (alarm_notice == 0 && (res == write_size || res == -EAGAIN));
if (res < 0) {
perror("qb_ipcc_sendv");
}
qb_util_stopwatch_stop(sw);
secs = qb_util_stopwatch_sec_elapsed_get(sw);
printf ("%5d messages sent ", write_count);
printf ("%5d bytes per write ", write_size);
printf ("%7.3f Seconds runtime ", secs);
printf ("%9.3f TP/s ",
((float)write_count) / secs);
printf ("%7.3f MB/s.\n",
((float)write_count) * ((float)write_size) / secs);
}
static void op_history_delete(struct pe_operation *op)
{
struct resource *r;
qb_map_iter_t *iter;
const char *key;
struct operation_history *oh;
qb_enter();
/*
* Delete this resource from any operational histories
*/
iter = qb_map_iter_create(op_history_map);
while ((key = qb_map_iter_next(iter, (void **)&oh)) != NULL) {
r = (struct resource *)oh->resource;
if (r == op->resource) {
/* stop the recurring monitor.
*/
if (qb_loop_timer_is_running(NULL, r->monitor_timer) &&
r->monitor_op) {
recurring_monitor_stop(r->monitor_op);
}
qb_map_rm(op_history_map, key);
free(oh->rsc_id);
free(oh->operation);
free(oh->op_digest);
free(oh);
}
}
qb_map_iter_free(iter);
qb_util_stopwatch_stop(op->time_execed);
pe_resource_completed(op, OCF_OK);
pe_resource_unref(op);
qb_leave();
}
static void
node_state_change_event(void* inst,
enum recover_state from,
enum recover_state to)
{
struct assembly *a = (struct assembly *)inst;
qb_enter();
qb_log(LOG_INFO, "Node (%s): changing state from %s to %s",
a->name, state_name_str[from], state_name_str[to]);
cape_admin_event_send(application->name, a, NULL,
state_str[from][to],
"bla");
if (to == RECOVER_STATE_RUNNING) {
qb_util_stopwatch_stop(a->sw_instance_connected);
qb_log(LOG_INFO, "Assembly '%s' connected in (%"PRIu64" ms).",
a->name,
qb_util_stopwatch_us_elapsed_get(a->sw_instance_connected) / QB_TIME_US_IN_MSEC);
node_update_addr_info(a);
}
schedule_processing();
qb_leave();
}
static void
test_this_one(const char *name, snprintf_like_func func)
{
int i;
qb_util_stopwatch_t *sw = qb_util_stopwatch_create();
float elapsed = 452.245252343;
float ops_per_sec = 0.345624523;
qb_util_stopwatch_start(sw);
for (i = 0; i < ITERATIONS; i++) {
func("%d %s %llu %9.3f", i, "hello", 3425ULL, elapsed);
func("[%10s] %.32x -> %p", "hello", i, func);
func("Client %s.%.9s wants to fence (%s) '%s' with device '%3.5f'",
"bla", "foooooooooooooooooo",
name, "target", ops_per_sec);
func("Node %s now has process list: %.32x (was %.32x)",
"18builder", 2, 0);
}
qb_util_stopwatch_stop(sw);
elapsed = qb_util_stopwatch_sec_elapsed_get(sw);
ops_per_sec = ((float)ITERATIONS) / elapsed;
printf("%s] Duration: %9.3f OPs/sec: %9.3f\n", name, elapsed, ops_per_sec);
qb_util_stopwatch_free(sw);
}
