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);
}
END_TEST
START_TEST(test_check_normal)
{
uint64_t res;
uint32_t last;
qb_util_stopwatch_t *sw = qb_util_stopwatch_create();
qb_util_stopwatch_split_ctl(sw, 3, 0);
qb_util_stopwatch_start(sw);
usleep(33000);
/* 1 */
res = qb_util_stopwatch_split(sw);
assert_int_between(res, 30000, 36000);
last = qb_util_stopwatch_split_last(sw);
ck_assert_int_eq(last, 0);
usleep(10000);
/* 2 */
res = qb_util_stopwatch_split(sw);
assert_int_between(res, 9000, 11000);
usleep(20000);
/* 3 */
res = qb_util_stopwatch_split(sw);
assert_int_between(res, 19000, 21000);
/* no more space */
res = qb_util_stopwatch_split(sw);
ck_assert_int_eq(res, 0);
/*
* split should be 30000 (10000 + 20000) usec
*/
last = qb_util_stopwatch_split_last(sw);
ck_assert_int_eq(last, 2);
res = qb_util_stopwatch_time_split_get(sw, last, 0);
assert_int_between(res, 25000, 35000);
/* ask for a split that has beyond the max.
*/
res = qb_util_stopwatch_time_split_get(sw, 3, 2);
ck_assert_int_eq(res, 0);
/* iterating
*/
last = qb_util_stopwatch_split_last(sw);
do {
res = qb_util_stopwatch_time_split_get(sw, last, last);
qb_log(LOG_INFO, "normal split %d is %"PRIu64"", last, res);
last--;
} while (res > 0);
qb_util_stopwatch_free(sw);
}
/*
* External API
*/
int32_t instance_create(struct assembly *assembly)
{
qb_enter();
qb_util_stopwatch_start(assembly->sw_instance_create);
image_id_get(assembly->name, image_id_get_completion, assembly);
instance_create_from_image_id(assembly->image_id, instance_create_completion, assembly);
qb_loop_job_add(NULL, QB_LOOP_LOW, assembly, my_instance_state_get);
qb_leave();
return 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 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
resource_monitor_execute(void *data)
{
struct pe_operation *op = (struct pe_operation *)data;
struct assembly *assembly;
struct resource *resource;
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_util_stopwatch_start(op->time_execed);
transport_resource_action(assembly, resource, op);
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);
}
static void bm_start(struct bm_ctx *ctx)
{
qb_util_stopwatch_start(ctx->sw);
}
