int main(int argc, char *argv[]) {
int err = 0;
unsigned int n;
qsup_server_t *srv0, *srv1;
qos_log_debug("Initing...");
qsup_init();
qsup_add_level_rule(0, d2bw(0.75));
qsup_add_group_constraints(0, build_constr(0, 1, d2bw(0.75), d2bw(0.3), 0));
/* Test check on max_min configured through rules */
qos_chk_exit(qsup_create_server(&srv0, 0, 0, build_params(0, d2bw(0.5), 0)) == QOS_E_UNAUTHORIZED);
qos_chk_ok_exit(qsup_create_server(&srv0, 0, 0, build_params(0, d2bw(0.2), 0)));
qos_chk_ok_exit(qsup_create_server(&srv1, 1, 0, build_params(0, d2bw(0.1), 0)));
qsup_dump();
for (n = 0; n < sizeof(bw_requests) / sizeof(pair_t); n++) {
int i;
struct timeval tv1, tv2;
qos_log_debug("n=%d", n);
gettimeofday(&tv1, NULL);
for (i = 0; i < 1000000; ++i)
qsup_set_required_bw(srv0, d2bw(bw_requests[n][0]));
gettimeofday(&tv2, NULL);
qos_log_debug("# microseconds: %g\n", (tv2.tv_usec - tv1.tv_usec + (tv2.tv_sec - tv1.tv_sec) * 1000000) / 1000000.0);
qsup_set_required_bw(srv1, d2bw(bw_requests[n][1]));
if (
(fabs(bw2d(qsup_get_approved_bw(srv0)) - bw_approved[n][0]) > tolerance)
|| (fabs(bw2d(qsup_get_approved_bw(srv1)) - bw_approved[n][1]) > tolerance)
) {
qos_log_err("Requests were %g, %g. Expecting %g, %g while got %g, %g.",
bw_requests[n][0], bw_requests[n][1],
bw_approved[n][0], bw_approved[n][1],
bw2d(qsup_get_approved_bw(srv0)), bw2d(qsup_get_approved_bw(srv1)));
err = -1;
}
}
qsup_dump();
qos_log_debug("Cleaning up supervisor");
qsup_cleanup();
return err;
}
int ibrdma_transfer(struct transfer_info *tfi, int num_tfi) {
struct addrinfo *addr;
struct rdma_cm_id *cmid= NULL;
struct rdma_event_channel *ec = NULL;
struct rdma_conn_param cm_params;
TEST_NZ(getaddrinfo(host, port, NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &cmid, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(cmid, NULL, addr->ai_addr, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ADDR_RESOLVED));
freeaddrinfo(addr);
build_connection(cmid);
TEST_NZ(rdma_resolve_route(cmid, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ROUTE_RESOLVED));
build_params(&cm_params);
TEST_NZ(rdma_connect(cmid, &cm_params));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ESTABLISHED));
on_connect(cmid->context);
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_DISCONNECTED));
rdma_destroy_id(&cmid);
rdma_destroy_event_channel(&ec);
return 0;
}
//static int run(int argc, char **argv)
int ibrdma_send(char* host, char* port, void* data, uint64_t size)
{
struct addrinfo *addr;
struct rdma_cm_id *cmid= NULL;
struct rdma_event_channel *ec = NULL;
struct rdma_conn_param cm_params;
TEST_NZ(getaddrinfo(host, port, NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &cmid, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(cmid, NULL, addr->ai_addr, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ADDR_RESOLVED));
freeaddrinfo(addr);
build_connection(cmid);
TEST_NZ(rdma_resolve_route(cmid, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ROUTE_RESOLVED));
build_params(&cm_params);
TEST_NZ(rdma_connect(cmid, &cm_params));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ESTABLISHED));
on_connect(cmid->context);
/* Init MSG send to start RDMA*/
init_tfile(data, size);
send_init(cmid->context);
/*----------------------------*/
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_DISCONNECTED));
rdma_destroy_id(cmid);
rdma_destroy_event_channel(ec);
return 0;
}
//static int run(int argc, char **argv)
//int RDMA_Connect(struct RDMA_communicator *comm, struct RDMA_param *param)
int RDMA_Active_Init(struct RDMA_communicator *comm, struct RDMA_param *param)
{
struct addrinfo *addr;
// struct rdma_cm_id *cm_id= NULL;
// struct rdma_event_channel *ec = NULL;
struct rdma_conn_param cm_params;
char port[8];
// int i,j;
sprintf(port, "%d", RDMA_PORT);
TEST_NZ(getaddrinfo(param->host, port, NULL, &addr));
TEST_Z(comm->ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(comm->ec, &(comm->cm_id), NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(comm->cm_id, NULL, addr->ai_addr, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(comm->ec, RDMA_CM_EVENT_ADDR_RESOLVED));
freeaddrinfo(addr);
build_connection(comm->cm_id);
TEST_NZ(rdma_resolve_route(comm->cm_id, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(comm->ec, RDMA_CM_EVENT_ROUTE_RESOLVED));
build_params(&cm_params);
TEST_NZ(rdma_connect(comm->cm_id, &cm_params));
TEST_NZ(wait_for_event(comm->ec, RDMA_CM_EVENT_ESTABLISHED));
// on_connect(cm_id->context);
return 0;
}
int main(int argc, char *argv[]) {
int err = 0;
unsigned int n;
qsup_server_t *srv0, *srv1;
qos_log_debug("Initing...");
qsup_init();
qsup_add_level_rule(0, d2bw(0.75));
qsup_add_group_constraints(0, build_constr(0, 1, d2bw(0.75), d2bw(0.3), 0));
/* Test check on max_min configured through rules */
qos_chk_exit(qsup_create_server(&srv0, 0, 0, build_params(0, d2bw(0.5), 0)) == QOS_E_UNAUTHORIZED);
qos_chk_ok_exit(qsup_create_server(&srv0, 0, 0, build_params(0, d2bw(0.1), 0)));
qos_chk_ok_exit(qsup_create_server(&srv1, 1, 0, build_params(0, d2bw(0.1), 0)));
qsup_dump();
for (n = 0; n < sizeof(bw_requests) / sizeof(pair_t); n++) {
qos_log_debug("n=%d", n);
qsup_set_required_bw(srv0, d2bw(bw_requests[n][0]));
qsup_set_required_bw(srv1, d2bw(bw_requests[n][1]));
if (
(fabs(bw2d(qsup_get_approved_bw(srv0)) - bw_approved[n][0]) > tolerance)
|| (fabs(bw2d(qsup_get_approved_bw(srv1)) - bw_approved[n][1]) > tolerance)
) {
qos_log_err("Requests were %g, %g. Expecting %g, %g while got %g, %g.",
bw_requests[n][0], bw_requests[n][1],
bw_approved[n][0], bw_approved[n][1],
bw2d(qsup_get_approved_bw(srv0)), bw2d(qsup_get_approved_bw(srv1)));
err = -1;
}
}
qsup_dump();
qos_log_debug("Destroying servers (earliest to latest)");
qos_chk_ok_exit(qsup_destroy_server(srv0));
qos_chk_ok_exit(qsup_destroy_server(srv1));
qos_log_debug("Cleaning up supervisor");
qsup_cleanup();
return err;
}
int client_on_route_resolved(struct rdma_cm_id *id)
{
struct rdma_conn_param cm_params;
build_params(&cm_params);
TEST_NZ(rdma_connect(id, &cm_params));
return 0;
}
Module GeneratorBase::build_module(const std::string &function_name,
const LoweredFunc::LinkageType linkage_type) {
build_params();
Pipeline pipeline = build_pipeline();
// Building the pipeline may mutate the params and imageparams.
rebuild_params();
return pipeline.compile_to_module(get_filter_arguments(), function_name, target, linkage_type);
}
GeneratorParamValues GeneratorBase::get_generator_param_values() {
build_params();
GeneratorParamValues results;
for (auto key_value : generator_params) {
GeneratorParamBase *param = key_value.second;
results[param->name] = param->to_string();
}
return results;
}
int on_route_resolved(struct rdma_cm_id *id)
{
struct rdma_conn_param cm_params;
printf("route resolved.\n");
build_params(&cm_params);
TEST_NZ(rdma_connect(id, &cm_params));
return 0;
}
int on_route_resolved(struct rdma_cm_id *id)
{
struct rdma_conn_param cm_params;
printf("route resolved.\n");
build_params(&cm_params);
TEST_NZ(rdma_connect(id, &cm_params));
//register_memory((struct connection *)(id->context));
return 0;
}
void GeneratorBase::set_generator_param_values(const GeneratorParamValues ¶ms) {
build_params();
for (auto key_value : params) {
const std::string &key = key_value.first;
const std::string &value = key_value.second;
auto param = generator_params.find(key);
user_assert(param != generator_params.end())
<< "Generator has no GeneratorParam named: " << key;
param->second->from_string(value);
}
}
int on_connect_request(struct rdma_cm_id *id)
{
struct rdma_conn_param cm_params;
printf("received connection request.\n");
build_connection(id);
build_params(&cm_params);
sprintf(get_local_message_region(id->context), "message from passive/server side with pid %d", getpid());
TEST_NZ(rdma_accept(id, &cm_params));
return 0;
}
void vtbuild(struct vtbuild *builder, const struct vt_token *token) {
switch (token->action) {
case VT_ACTION_EXECUTE:
case VT_ACTION_PRINT:
builder->cb(builder, token->ch);
break;
case VT_ACTION_ESC_DISPATCH:
builder->cb(builder, ESC);
/* TODO check, may be the following two lines should be swapped. -- Eldar*/
builder->cb(builder, token->ch);
build_attrs(builder, token->attrs,
min(token->attrs_len, VT_TOKEN_ATTRS_MAX));
break;
case VT_ACTION_CSI_DISPATCH:
builder->cb(builder, ESC);
builder->cb(builder, CSI);
build_params(builder, token->params, token->params_len);
build_attrs(builder, token->attrs,
min(token->attrs_len, VT_TOKEN_ATTRS_MAX));
builder->cb(builder, token->ch);
break;
case VT_ACTION_OSC_START:
case VT_ACTION_OSC_PUT:
case VT_ACTION_OSC_END:
/* Operating System Command */
/* ignore them as unused in our system
-- Eldar*/
case VT_ACTION_HOOK:
case VT_ACTION_PUT:
case VT_ACTION_UNHOOK:
/* device control strings */
/* ignore them as unused in our system
-- Eldar*/
break;
case VT_ACTION_IGNORE:
case VT_ACTION_COLLECT:
case VT_ACTION_PARAM:
case VT_ACTION_CLEAR:
/* ignore as VTParser internal states*/
break;
default:
/* unknown action
do not fail, just ignore it*/
break;
}
}
void GeneratorBase::emit_filter(const std::string &output_dir,
const std::string &function_name,
const std::string &file_base_name,
const EmitOptions &options) {
build_params();
Pipeline pipeline = build_pipeline();
std::vector<Halide::Argument> inputs = get_filter_arguments();
std::string base_path = output_dir + "/" + (file_base_name.empty() ? function_name : file_base_name);
if (options.emit_o || options.emit_assembly || options.emit_bitcode) {
Outputs output_files;
if (options.emit_o) {
// If the target arch is pnacl, then the output "object" file is
// actually a pnacl bitcode file.
if (Target(target).arch == Target::PNaCl) {
output_files.object_name = base_path + ".bc";
} else if (Target(target).os == Target::Windows &&
!Target(target).has_feature(Target::MinGW)) {
// If it's windows, then we're emitting a COFF file
output_files.object_name = base_path + ".obj";
} else {
// Otherwise it is an ELF or Mach-o
output_files.object_name = base_path + ".o";
}
}
if (options.emit_assembly) {
output_files.assembly_name = base_path + ".s";
}
if (options.emit_bitcode) {
// In this case, bitcode refers to the LLVM IR generated by Halide
// and passed to LLVM, for both the pnacl and ordinary archs
output_files.bitcode_name = base_path + ".bc";
}
pipeline.compile_to(output_files, inputs, function_name, target);
}
if (options.emit_h) {
pipeline.compile_to_header(base_path + ".h", inputs, function_name, target);
}
if (options.emit_cpp) {
pipeline.compile_to_c(base_path + ".cpp", inputs, function_name, target);
}
if (options.emit_stmt) {
pipeline.compile_to_lowered_stmt(base_path + ".stmt", inputs, Halide::Text, target);
}
if (options.emit_stmt_html) {
pipeline.compile_to_lowered_stmt(base_path + ".html", inputs, Halide::HTML, target);
}
}
static void accept_connection(struct rdma_cm_id *id)
{
struct rdma_conn_param conn_param;
/*
simple_context_t *context = malloc(sizeof(*context));
if (!context)
{
perror("failed to malloc context for connection\n");
rdma_reject(id, NULL, 0);
return;
}
// associate this context with this id.
context->id = id;
id->context = context;
context->quit_cq_thread = 0;
if (allocate_server_resources(context))
{
fprintf(stderr, "failed to allocate resources\n");
rdma_reject(id, NULL, 0);
return;
}
post_server_rec_work_req(context);
*/
printf("Accepting connection on id == %p (total connections %d)\n",
id, ++connections);
build_connection_s(id);
// memset(&conn_param, 0, sizeof(conn_param));
// conn_param.responder_resources = 1;
// conn_param.initiator_depth = 1;
build_params(&conn_param);
// sprintf(get_local_message_region(id->context), "message from passive/server side with pid %d", getpid());
// rdma_accept(context->id, &conn_param);
TEST_NZ(rdma_accept(id, &conn_param));
//if (query_qp_on_alloc)
// {
// debug_print_qp(context);
// }
}
/*
* Load kernel image into entry point address. Assumes that the fs buffer has
* been filled.
*/
static u32 load_kernel(char *cmdline)
{
u32 entry_point;
struct image_header *hdr;
if(tfs_load_file("uImage", (u32 *)(0x8000-sizeof(image_header_t))) != 0)
return 0;
build_params(cmdline, (struct tag *)params_buffer);
hdr = (struct image_header *)(0x8000-sizeof(image_header_t));
if(ntohl(hdr->ih_magic) != IH_MAGIC) {
db_puts("ERROR: bad magic number\n");
return 0;
}
#ifdef CHECK_KERNEL_CRC
do {
u32 checksum;
checksum = ntohl(hdr->ih_hcrc);
hdr->ih_hcrc = 0;
/* check uImage header CRC */
if(crc32(0, (u8 *)hdr, sizeof(image_header_t)) != checksum) {
db_puts("ERROR: header CRC mismatch\n");
}
/* check uImage data CRC */
checksum = crc32(0, (u8 *)hdr+sizeof(image_header_t),
ntohl(hdr->ih_size));
if(checksum != ntohl(hdr->ih_dcrc)) {
db_puts("ERROR: bad data CRC\n");
return 0;
}
} while(0);
#endif
entry_point = ntohl(hdr->ih_ep);
/* Retrieve the kernel image's contents in such a way that the image
* header is skipped and the actual start of the kernel sits at the
* entry point. */
return entry_point;
}
int on_route_resolved(struct rdma_cm_id *id)
{
struct rdma_conn_param cm_params;
struct timeval start, end, dt;
printf("route resolved.\n");
build_params(&cm_params);
TEST_NZ(rdma_connect(id, &cm_params));
gettimeofday(&start, NULL);
register_memory((struct connection *)(id->context));
gettimeofday(&end, NULL);
timersub(&end, &start, &dt);
long usec = dt.tv_usec + 1000000 * dt.tv_sec;
printf("[Register] takes %ld micro_secs.\n", usec);
post_receive_for_msg(id->context);
return 0;
}
int ibrdma_transfer(struct transfer_info tfi, int num_tfi) {
struct addrinfo *addr;
struct rdma_cm_id *cmid= NULL;
struct rdma_event_channel *ec = NULL;
struct rdma_conn_param cm_params;
int i,j;
/*Allocation buffer space for reading from local fs to memory*/
struct transfer_file *ffile = tfi.tfiles;
int nf = tfi.tfiles;
char* host = tfi.ib_host;
char* port; sprintf(port,"%d",tfi.ib_port);
for (i = 0; i < NUM_FILE_BUF_C; i++) {
tfi.fbufs[i].fbuf = (char *)malloc(FILE_BUF_SIZE_C);
tfi.fbufs[i].size = 0;
}
TEST_NZ(getaddrinfo(host, port, NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &cmid, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(cmid, NULL, addr->ai_addr, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ADDR_RESOLVED));
freeaddrinfo(addr);
build_connection(cmid);
TEST_NZ(rdma_resolve_route(cmid, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ROUTE_RESOLVED));
build_params(&cm_params);
TEST_NZ(rdma_connect(cmid, &cm_params));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ESTABLISHED));
on_connect(cmid->context);
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_DISCONNECTED));
rdma_destroy_id(&cmid);
rdma_destroy_event_channel(&ec);
return 0;
}
void build_hr0( int flag, int precflag )/* 0, fresh start, 1--restart with stored vectors,*/
{
register int i,j;
register site *s;
int total_R_iters ;
Real re,im;
complex cc;
int nn0;
Real eigenval_tol_save;
/* code for good h(-r0) eigenmodes */
int failed,ifailed,nextra;
double *MyeigVal0;
wilson_vector **MyeigVec0;
wilson_vector *tmpvec;
Real ftmp;
Real invp,invp5;
tmpvec=(wilson_vector*)malloc(sites_on_node*sizeof(wilson_vector));
nn0=-ndelta0;
if (precflag==HIGHP)
{
eigenval_tol=eigenval_tol_high;
error_decr=error_decr_high;
} else {
eigenval_tol=eigenval_tol_low;
error_decr=error_decr_low;
}
node0_printf("\n");
eigenval_tol_save=eigenval_tol;
build_params(-R0);
make_clov1();
kind_of_h0=HZERO;
if(Maxr0Iter != 0){
/*
FORALLSITES(i,s){
clear_wvec(&(eigVec0[0][i]));
if(s->x==0 && s->y==0 && s->z==0 && s->t==0) eigVec0[0][i].d[0].c[0].real=1.0;
}
delta0_field(eigVec0[0],eigVec0[1],PLUS);
FORALLSITES(i,s){
if(s->x ==0 && s ->y==0 && s->z==0){
node0_printf("DT %d %d %d %d\n",s->x,s->y,s->z,s->t);
dump_wvec(&(eigVec0[1][i]));
}
}
*/
/* initialize the CG vectors */
if(flag==0)
{
if(this_node==0) printf("random initial vectors for h(m0)\n");
/* Initiallize all the eigenvectors to a random vector */
for(j=0;j<Nvecs_h0r0;j++){
grsource_dirac(EVENANDODD);
FORSOMEPARITY(i,s,EVENANDODD){
copy_wvec(&(s->g_rand),&(eigVec0[j][i]));
}
eigVal0[j]=1.0e+16;
}
}
else
{
/* eigenvectors and eigenvalues of h(-r0) already exist, but we need eigenvalues of h^2 */
for(j=0;j<Nvecs_h0r0;j++){
//static int run(int argc, char **argv)
//int RDMA_Connect(struct RDMA_communicator *comm, struct RDMA_param *param)
int RDMA_Active_Init(struct RDMA_communicator *comm, struct RDMA_param *param)
{
struct addrinfo *addr;
// struct rdma_cm_id *cm_id= NULL;
// struct rdma_event_channel *ec = NULL;
struct rdma_conn_param cm_params;
char port[8];
// int i,j;
sprintf(port, "%d", RDMA_PORT);
if(getaddrinfo(param->host, port, NULL, &addr)){
fprintf(stderr, "RDMA lib: SEND: ERROR: getaddrinfo failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
if(!(comm->ec = rdma_create_event_channel())){
fprintf(stderr, "RDMA lib: SEND: ERROR: rdma event channel create failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
if (rdma_create_id(comm->ec, &(comm->cm_id), NULL, RDMA_PS_TCP)){
fprintf(stderr, "RDMA lib: SEND: ERROR: rdma id create failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
if (rdma_resolve_addr(comm->cm_id, NULL, addr->ai_addr, TIMEOUT_IN_MS)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: rdma address resolve failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
if (wait_for_event(comm->ec, RDMA_CM_EVENT_ADDR_RESOLVED)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: event wait failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
freeaddrinfo(addr);
build_connection(comm->cm_id);
if (rdma_resolve_route(comm->cm_id, TIMEOUT_IN_MS)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: rdma route resolve failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
if (wait_for_event(comm->ec, RDMA_CM_EVENT_ROUTE_RESOLVED)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: event wait failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
build_params(&cm_params);
if (rdma_connect(comm->cm_id, &cm_params)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: rdma connection failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
if (wait_for_event(comm->ec, RDMA_CM_EVENT_ESTABLISHED)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: event wait failed @ %s:%d\n", __FILE__, __LINE__);
exit(1);
}
// on_connect(cm_id->context);
int i ;
for (i = 0; i < RDMA_BUF_NUM_C; i++){ rdma_msg_mr[i] = NULL;}
char *value;
value = getenv("RDMA_CLIENT_NUM_S");
if (value == NULL) {
rdma_buf_size = RDMA_BUF_SIZE_C;
} else {
rdma_buf_size = MAX_RDMA_BUF_SIZE_C / atoi(value);
}
fprintf(stderr, "rdma_buf_size: %d\n", rdma_buf_size);
return 0;
}
static int init_db(struct dbops_action* p)
{
db_fld_t* matches = NULL, *result = NULL, *values = NULL;
int type, i;
DEBUG(MODULE_NAME": init_db: query: %s(%d)\n", p->query_name, p->query_no);
if (p->db_url == NULL) {
ERR(MODULE_NAME": No database URL specified\n");
return -1;
}
p->ctx = db_ctx(MODULE_NAME);
if (p->ctx == NULL) {
ERR(MODULE_NAME": Error while initializing database layer\n");
return -1;
}
if (db_add_db(p->ctx, p->db_url) < 0) return -1;
if (db_connect(p->ctx) < 0) return -1;
if (p->is_raw_query) {
type = DB_SQL;
if (build_params(&matches, p) < 0) return -1;
}
else {
switch(p->operation) {
case INSERT_OPS:
case REPLACE_OPS:
type = DB_PUT;
if (build_params(&values, p) < 0) return -1;
break;
case UPDATE_OPS:
type = DB_UPD;
if (build_match(&matches, p) < 0) return -1;
if (build_params(&values, p) < 0) {
if (matches) pkg_free(matches);
return -1;
}
break;
case DELETE_OPS:
type = DB_DEL;
if (build_match(&matches, p) < 0) return -1;
break;
case OPEN_QUERY_OPS:
type = DB_GET;
if (build_match(&matches, p) < 0) return -1;
if (build_result(&result, p) < 0) {
if (matches) pkg_free(matches);
return -1;
}
break;
default:
BUG("Unknown operation %d\n", p->operation);
return -1;
}
}
p->cmd = db_cmd(type, p->ctx, p->table.s, result, matches, values);
if (p->cmd == NULL) {
ERR(MODULE_NAME": init_db: query: %s(%d), error while compiling database query\n", p->query_name, p->query_no);
if (values) pkg_free(values);
if (matches) pkg_free(matches);
if (result) pkg_free(result);
db_disconnect(p->ctx);
db_ctx_free(p->ctx);
return -1;
}
if (values) pkg_free(values);
if (matches) pkg_free(matches);
if (result) pkg_free(result);
for (i=0; i<p->extra_ops_count; i++) {
char *end;
DEBUG(MODULE_NAME": init_db: query_no: %s(%d), setopt('%s', %i, '%s'\n", p->query_name, p->query_no, p->extra_ops[i].name, p->extra_ops[i].type, p->extra_ops[i].value);
switch (p->extra_ops[i].type) {
case DB_NONE:
/* set null ?? */
break;
case DB_DATETIME: {
time_t v;
v = strtol(p->extra_ops[i].value, &end, 10);
if (db_setopt(p->cmd, p->extra_ops[i].name, v) < 0) return -1;
break;
}
case DB_INT: {
int v;
v = strtol(p->extra_ops[i].value, &end, 10);
if (db_setopt(p->cmd, p->extra_ops[i].name, v) < 0) return -1;
break;
}
case DB_FLOAT: {
float v;
#ifdef __USE_ISOC99
v = strtof(p->extra_ops[i].value, &end);
#else
v = strtod(p->extra_ops[i].value, &end);
#endif
if (db_setopt(p->cmd, p->extra_ops[i].name, v) < 0) return -1;
break;
}
case DB_DOUBLE: {
double v;
v = strtod(p->extra_ops[i].value, &end);
if (db_setopt(p->cmd, p->extra_ops[i].name, v) < 0) return -1;
break;
}
case DB_CSTR:
if (db_setopt(p->cmd, p->extra_ops[i].name, p->extra_ops[i].value) < 0) return -1;
break;
default:
BUG("Unknown extra_op type: %d\n", p->extra_ops[i].type);
return -1;
}
}
return 0;
}
static int run(int argc, char **argv)
{
struct addrinfo *addr;
//struct rdma_cm_event *event = NULL;
struct rdma_cm_id *cmid= NULL;
struct rdma_event_channel *ec = NULL;
struct rdma_conn_param cm_params;
if (argc != 4)
usage(argv[0]);
if (strcmp(argv[1], "write") == 0)
set_mode(M_WRITE);
else if (strcmp(argv[1], "read") == 0)
set_mode(M_READ);
else
usage(argv[0]);
TEST_NZ(getaddrinfo(argv[2], argv[3], NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
/*create rdma socket*/
TEST_NZ(rdma_create_id(ec, &cmid, NULL, RDMA_PS_TCP));
/* int rdma_resolve_addr (struct rdma_cm_id *id, struct sockaddr *src_addr,
struct sockaddr dst_addr, int timeout_ms)
id RDMA identifier
src_addr Source address information. This parameter may be NULL.
dst_addr Destination address information
timeout_ms Time to wait for resolution to complete
Description:
Resolve destination and optional source addresses from IP addresses
to an RDMA address. If suc- cessful,
the specified rdma_cm_id will be bound to a local device.
*/
TEST_NZ(rdma_resolve_addr(cmid, NULL, addr->ai_addr, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ADDR_RESOLVED));
freeaddrinfo(addr);
build_connection(cmid);
sprintf(get_local_message_region(cmid->context), "message from active/client side with pid %d", getpid());
/*--------------------*/
/* int rdma_resolve_route (struct rdma_cm_id *id, int timeout_ms);
id RDMA identifier
timeout_ms Time to wait for resolution to complete
Description:
Resolves an RDMA route to the destination address in order
to establish a connection. The destination address must have
already been resolved by calling rdma_resolve_addr.
*/
TEST_NZ(rdma_resolve_route(cmid, TIMEOUT_IN_MS));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ROUTE_RESOLVED));
/* -------------------- */
print_path_rec(cmid);
/* int rdma_connect (struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
id RDMA identifier
conn_param connection parameters
Description:
For an rdma_cm_id of type RDMA_PS_TCP, this call initiates a connection
request to a remote destination. For an rdma_cm_id of type RDMA_PS_UDP,
it initiates a lookup of the remote QP providing the datagram service
*/
build_params(&cm_params);
printf("Connecting ...\n");
TEST_NZ(rdma_connect(cmid, &cm_params));
TEST_NZ(wait_for_event(ec, RDMA_CM_EVENT_ESTABLISHED));
printf("Connected !\n");
/* --------------------- */
/*TODO: do something */
on_connect(cmid->context);
send_mr(cmid->context);
/*--------------------*/
rdma_disconnect(cmid);
rdma_destroy_id(cmid);
rdma_destroy_event_channel(ec);
return 0;
/*=================*/
/*=================*/
/*
while (rdma_get_cm_event(ec, &event) == 0) {
memcpy(&event_copy, event, sizeof(*event));
rdma_ack_cm_event(event);
if (on_event(&event_copy))
break;
}
*/
}
int main(int argc, char *argv[])
{
int meascount;
int prompt;
Real avm_iters,avs_iters;
double ssplaq,stplaq;
double starttime,endtime;
double dtime;
int MinCG,MaxCG;
Real size_r,RsdCG;
register int i,j,l;
register site *s;
int spinindex,spin,color,k,kk,t;
int flag;
int ci,si,sf,cf;
int num_prop;
Real space_vol;
int status;
int source_chirality;
wilson_vector **eigVec ;
double *eigVal ;
int total_R_iters ;
double norm;
Real re,im,re5,im5;
complex cc;
char label[20] ;
double *grad, *err, max_error;
Matrix Array,V ;
int key[4];
#define restrict rstrict /* C-90 T3D cludge */
int restrict[4];
Real norm_fac[10];
static char *mes_kind[10] = {"PION","PS505","PS055","PS0505",
"RHO33","RHO0303","SCALAR","SCALA0","PV35","B12"};
static char *bar_kind[4] = {"PROTON","PROTON0","DELTA","DELTA0"};
complex *pmes_prop[MAX_MASSES][10];
complex *smes_prop[MAX_MASSES][10];
complex *bar_prop[MAX_MASSES][4];
w_prop_file *fp_in_w[MAX_MASSES]; /* For propagator files */
w_prop_file *fp_out_w[MAX_MASSES]; /* For propagator files */
initialize_machine(&argc,&argv);
/* Remap standard I/O */
if(remap_stdio_from_args(argc, argv) == 1)terminate(1);
g_sync();
/* set up */
prompt = setup_p();
/* loop over input sets */
while( readin(prompt) == 0)
{
starttime=dclock();
MaxCG=niter;
avm_iters=0.0;
meascount=0;
if(this_node==0)printf("END OF HEADER\n");
setup_offset();
/*
if(this_node==0)printf("warning--no fat link\n");
*/
monte_block_ape_b(1);
/* call plaquette measuring process */
d_plaquette(&ssplaq,&stplaq);
if(this_node==0)printf("FATPLAQ %e %e\n",
(double)ssplaq,(double)stplaq);
/* flip the time oriented fat links
if(this_node==0) printf("Periodic time BC\n");
*/
if(this_node==0) printf("AP time BC\n");
boundary_flip(MINUS);
setup_links(SIMPLE);
/* if(this_node==0) printf("num_masses = %d\n", num_masses); */
/* Loop over mass */
for(k=0;k<num_masses;k++){
m0=mass[k];
if(m0 <= -10.0) exit(1);
RsdCG=resid[k];
if(this_node==0)printf("mass= %g r0= %g residue= %g\n",
(double)m0,(double)wqs[k].r0,(double)RsdCG);
build_params(m0);
make_clov1();
eigVal = (double *)malloc(Nvecs*sizeof(double));
eigVec = (wilson_vector **)malloc(Nvecs*sizeof(wilson_vector*));
for(i=0;i<Nvecs;i++)
eigVec[i]=
(wilson_vector*)malloc(sites_on_node*sizeof(wilson_vector));
/* open files for wilson propagators */
fp_in_w[k] = r_open_wprop(startflag_w[k], startfile_w[k]);
fp_out_w[k] = w_open_wprop(saveflag_w[k], savefile_w[k],
wqs[k].type);
if(startflag_w[k] == FRESH)flag = 0;
else
flag = 1;
spin=color=0; /* needed by wilson writing routines */
/* initialize the CG vectors */
if(flag==0){
if(this_node==0) printf("random (but chiral) initial vectors\n");
/* Initiallize all the eigenvectors to a random vector */
for(j=0;j<Nvecs;j++)
{
if(j< Nvecs/2){ source_chirality=1;}
else{source_chirality= -1;}
printf("source chirality %d\n",source_chirality);
grsource_w();
FORALLSITES(i,s){
copy_wvec(&(s->g_rand),&(eigVec[j][i]));
if(source_chirality==1){
for(kk=2;kk<4;kk++)for(l=0;l<3;l++)
eigVec[j][i].d[kk].c[l]=cmplx(0.0,0.0);
}
if(source_chirality== -1){
for(kk=0;kk<2;kk++)for(l=0;l<3;l++)
eigVec[j][i].d[kk].c[l]=cmplx(0.0,0.0);
}
}
eigVal[j]=1.0e+16;
}
}
else{
if(this_node==0) printf("reading in %d wilson_vectors--must be <= 12\n",Nvecs);
/* load psi if requested */
for(j=0;j<Nvecs;j++){
printf("reading %d %d %d\n",j,spin,color);
#ifdef IOTIME
status = reload_wprop_sc_to_site( startflag_w[k], fp_in_w[k],
spin, color, F_OFFSET(psi),1);
#else
status = reload_wprop_sc_to_site( startflag_w[k], fp_in_w[k],
spin, color, F_OFFSET(psi),0);
#endif
/* compute eigenvalue */
herm_delt(F_OFFSET(psi),F_OFFSET(chi));
re=im=0.0;
FORALLSITES(i,s){
cc = wvec_dot( &(s->chi), &(s->psi) );
re += cc.real ;
}
g_floatsum(&re);
eigVal[j]=re;
printf("trial eigenvalue of state %d %e\n",j,eigVal[j]);
FORALLSITES(i,s){eigVec[j][i]=s->psi;}
spin++;
if((spin %4) == 0){spin=0;color++;}
}
}
void GeneratorBase::rebuild_params() {
params_built = false;
filter_arguments.clear();
generator_params.clear();
build_params();
}
// Handle a set of case methods, starting at the given method.
// Generate wrapper and worker methods and append them to the given list.
// Returns: true on success, false on failure.
static bool sugar_case_method(ast_t* first_case_method, ast_t* members,
const char* name, typecheck_t* t)
{
assert(first_case_method != NULL);
assert(members != NULL);
assert(name != NULL);
assert(t != NULL);
ast_t* wrapper = make_match_wrapper(first_case_method);
if(wrapper == NULL)
return false;
ast_t* match_cases = ast_from(first_case_method, TK_CASES);
ast_scope(match_cases);
// Process all methods with the same name.
// We need to remove processed methods. However, removing nodes from a list
// we're iterating over gets rather complex. Instead we mark nodes and remove
// them all in one sweep later.
for(ast_t* p = first_case_method; p != NULL; p = ast_sibling(p))
{
const char* p_name = ast_name(ast_childidx(p, 1));
if(p_name == name)
{
// This method is in the case set.
ast_t* case_ast = add_case_method(wrapper, p);
if(case_ast == NULL)
{
ast_free(wrapper);
ast_free(match_cases);
return false;
}
ast_append(match_cases, case_ast);
ast_setid(p, TK_NONE); // Mark for removal.
}
}
// Check params and build match operand, worker parameters and worker call
// arguments.
ast_t* match_params = ast_childidx(wrapper, 3);
ast_t* worker_params = ast_from(match_params, TK_PARAMS);
ast_t* call_args = ast_from(match_params, TK_POSITIONALARGS);
ast_t* match_operand = build_params(match_params, worker_params, call_args,
name, t);
if(match_operand == NULL)
{
ast_free(wrapper);
ast_free(match_cases);
ast_free(worker_params);
ast_free(call_args);
return false;
}
// Complete wrapper function and add to containing entity.
const char* worker_name = package_hygienic_id(t);
ast_t* wrapper_body = ast_childidx(wrapper, 6);
ast_t* wrapper_call;
ast_t* call_t_args = ast_from(wrapper, TK_NONE);
assert(ast_id(wrapper_body) == TK_SEQ);
assert(ast_childcount(wrapper_body) == 0);
build_t_params(ast_childidx(wrapper, 2), call_t_args);
if(ast_id(call_t_args) == TK_NONE)
{
// No type args needed.
ast_free(call_t_args);
BUILD(tmp, wrapper_body,
NODE(TK_CALL,
TREE(call_args)
NONE
NODE(TK_REFERENCE, ID(worker_name))));
wrapper_call = tmp;
}
else
{
// Type args needed on call.
BUILD(tmp, wrapper_body,
NODE(TK_CALL,
TREE(call_args)
NONE
NODE(TK_QUALIFY,
NODE(TK_REFERENCE, ID(worker_name))
TREE(call_t_args))));
wrapper_call = tmp;
}
ast_append(wrapper_body, wrapper_call);
ast_append(members, wrapper);
// Make worker function and add to containing entity.
AST_GET_CHILDREN(wrapper, cap, wrapper_id, t_params, wrapper_params,
ret_type, error);
if(ast_id(wrapper) == TK_BE)
cap = ast_from(cap, TK_REF);
BUILD(worker, wrapper,
NODE(TK_FUN, AST_SCOPE
TREE(cap)
ID(worker_name)
TREE(t_params)
TREE(worker_params)
TREE(ret_type)
TREE(error)
NODE(TK_SEQ,
NODE(TK_MATCH, AST_SCOPE
NODE(TK_SEQ, TREE(match_operand))
TREE(match_cases)
NONE)) // Else clause.
NONE // Doc string.
NONE)); // Guard.
ast_append(members, worker);
return true;
}
