Page MenuHomeClusterLabs Projects
Files F1841854

bmcpt.c
No OneTemporary
Actions

bmcpt.c
View Options

/*
* Copyright (c) 2009 Red Hat, Inc.
*
* All rights reserved.
*
* Author: Steven Dake (sdake@redhat.com)
*
* libqb is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 2.1 of the License, or
* (at your option) any later version.
*
* libqb is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with libqb. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <assert.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include <signal.h>
#include <qb/qbdefs.h>
#include <qb/qbutil.h>
#include <qb/qbipcc.h>
#define ITERATIONS 10000000
#define THREADS 4
struct bm_ctx {
qb_ipcc_connection_t *conn;
qb_util_stopwatch_t *sw;
float mbs;
float secs;
int32_t multi;
uint32_t counter;
};
static void bm_start(struct bm_ctx *ctx)
{
qb_util_stopwatch_start(ctx->sw);
}
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 bmc_connect(struct bm_ctx *ctx)
{
ctx->sw = qb_util_stopwatch_create();
ctx->conn = qb_ipcc_connect("bm1", QB_MAX(1000 * (100 + THREADS),
1024*1024));
if (ctx->conn == NULL) {
perror("qb_ipcc_connect");
exit(-1);
}
}
static void bmc_disconnect(struct bm_ctx *ctx)
{
qb_ipcc_disconnect(ctx->conn);
qb_util_stopwatch_free(ctx->sw);
}
struct my_req {
struct qb_ipc_request_header hdr;
char message[1024 * 1024];
};
static struct my_req request;
static int32_t bmc_send_nozc(struct bm_ctx *ctx, uint32_t size)
{
struct qb_ipc_response_header res_header;
int32_t res;
request.hdr.id = QB_IPC_MSG_USER_START + 3;
request.hdr.size = sizeof(struct qb_ipc_request_header) + size;
repeat_send:
res = qb_ipcc_send(ctx->conn, &request, request.hdr.size);
if (res < 0) {
if (res == -EAGAIN) {
goto repeat_send;
} else if (res == -EINVAL || res == -EINTR) {
perror("qb_ipcc_send");
return -1;
} else {
errno = -res;
perror("qb_ipcc_send");
goto repeat_send;
}
}
res = qb_ipcc_recv(ctx->conn, &res_header,
sizeof(struct qb_ipc_response_header), -1);
if (res == -EINTR) {
return -1;
}
if (res < 0) {
perror("qb_ipcc_recv");
}
assert(res == sizeof(struct qb_ipc_response_header));
assert(res_header.id == 13);
assert(res_header.size == sizeof(struct qb_ipc_response_header));
return 0;
}
uint32_t alarm_notice = 0;
static void sigalrm_handler(int32_t num)
{
alarm_notice = 1;
}
static void *benchmark(void *ctx)
{
struct bm_ctx *bm_ctx = (struct bm_ctx *)ctx;
int32_t res;
bmc_connect(bm_ctx);
bm_start(bm_ctx);
for (;;) {
bm_ctx->counter++;
res = bmc_send_nozc(bm_ctx, 1000 * bm_ctx->multi);
if (alarm_notice || res == -1) {
bm_finish(bm_ctx, "send_nozc", 1000 * bm_ctx->multi);
bmc_disconnect(bm_ctx);
return (NULL);
}
}
}
int32_t main(void)
{
struct bm_ctx bm_ctx[THREADS];
pthread_t threads[THREADS];
pthread_attr_t thread_attr[THREADS];
int32_t i, j;
float total_mbs;
void *retval;
for (i = 0; i < THREADS; i++) {
bm_ctx[i].mbs = 0;
}
signal(SIGALRM, sigalrm_handler);
for (j = 0; j < 500; j++) {
alarm_notice = 0;
alarm(3);
for (i = 0; i < THREADS; i++) {
bm_ctx[i].multi = j + 100;
bm_ctx[i].counter = 0;
pthread_attr_init(&thread_attr[i]);
pthread_attr_setdetachstate(&thread_attr[i],
PTHREAD_CREATE_JOINABLE);
pthread_create(&threads[i], &thread_attr[i], benchmark,
&bm_ctx[i]);
}
for (i = 0; i < THREADS; i++) {
pthread_join(threads[i], &retval);
}
total_mbs = 0;
for (i = 0; i < THREADS; i++) {
total_mbs = total_mbs + bm_ctx[i].mbs;
}
printf("%d ", 1000 * bm_ctx[0].multi);
printf("%9.3f\n", total_mbs);
}
return EXIT_SUCCESS;
}

File Metadata

Mime Type
text/x-c
Expires
Sat, Nov 23, 8:47 AM (23 h, 52 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1013638
Default Alt Text
bmcpt.c (4 KB)

Event Timeline