void
getsucc_cb (chordID dest, str desthost,
chord_nodelistextres *res, u_int64_t start, clnt_stat err, vec<float> coords, float e)
{
assert (err == 0 && res->status == CHORD_OK);
assert (res->resok->nlist.size () >= 2);
if (coords.size () == 0)
warnx << dest << " " << desthost << "\n";
else {
char s[1024];
sprintf (s, "%f %f %f e=%f", coords[0], coords[1], coords[2], e/Coord::PRED_ERR_MULT);
warnx << dest << " " << desthost << " "
<< s << " "
<< (getusec () - start) << " "
<< "\n";
}
chord_node z = make_chord_node (res->resok->nlist[1].n);
// wrapped around ring. done.
if (z.x == wellknown_ID) {
warnx << getusec () << "--------------------------\n";
exit (0);
}
getsucc (z);
}
void DEX_PASS_MGR::perform_scalar_opt(OPT_CTX & oc)
{
LIST<IR_OPT*> opt_list; //A list of optimization.
IR_SSA_MGR * ssamgr = (IR_SSA_MGR*)register_opt(OPT_SSA_MGR);
bool is_ssa_avail = false;
if (ssamgr != NULL) {
is_ssa_avail = ssamgr->is_ssa_construct();
}
opt_list.append_tail(register_opt(OPT_CP));
opt_list.append_tail(register_opt(OPT_DCE));
opt_list.append_tail(register_opt(OPT_RP));
opt_list.append_tail(register_opt(OPT_CP));
opt_list.append_tail(register_opt(OPT_DCE));
opt_list.append_tail(register_opt(OPT_RP));
opt_list.append_tail(register_opt(OPT_CP));
opt_list.append_tail(register_opt(OPT_DCE));
opt_list.append_tail(register_opt(OPT_LOOP_CVT));
opt_list.append_tail(register_opt(OPT_LICM));
opt_list.append_tail(register_opt(OPT_GCSE));
((IR_DCE*)register_opt(OPT_DCE))->set_elim_cfs(false);
((IR_DCE*)register_opt(OPT_DCE))->set_ssa_available(is_ssa_avail);
if (opt_list.get_elem_count() != 0) {
LOG("\tScalar optimizations for '%s'", m_ru->get_ru_name());
}
bool change;
UINT count = 0;
//do {
change = false;
for (IR_OPT * opt = opt_list.get_head();
opt != NULL; opt = opt_list.get_next()) {
CHAR const* optn = opt->get_opt_name();
LOG("\t\tpass %s", optn);
IS_TRUE0(verify_ir_and_bb(m_ru->get_bb_list(), m_dm));
ULONGLONG t = getusec();
//dump_bbs(m_ru->get_bb_list(), "before");
//m_ru->get_cfg()->dump_vcg("before.vcg");
bool doit = opt->perform(oc);
//dump_bbs(m_ru->get_bb_list(), "after");
//m_ru->get_cfg()->dump_vcg("after.vcg");
append_ti(opt->get_opt_name(), getusec() - t);
if (doit) {
LOG("\t\t\tchanged");
change = true;
IS_TRUE0(verify_ir_and_bb(m_ru->get_bb_list(), m_dm));
IS_TRUE0(m_ru->get_cfg()->verify());
}
}
count++;
//} while (change && count < 20);
//IS_TRUE0(!change);
}
static
void do_pp_client(void)
{
unsigned long t1, t2;
double time;
double throuput;
unsigned int msgsize;
double ms;
int res;
double loops = arg_loops;
memset(abuffer, 24, sizeof(*abuffer));
if (!arg_pscom) {
printf("Warning! This is not a ping pong with msize Messagesize!!!\n");
}
printf("%7s %8s %8s %8s\n", "msize", "loops", "time", "throughput");
printf("%7s %8s %8s %8s\n", "[bytes]", "[cnt]", "[us/cnt]", "[MB/s]");
for (ms = 1.4142135; ms < arg_maxmsize; ms = ms * 1.4142135) {
unsigned int iloops = loops;
msgsize = ms + 0.5;
if (((unsigned)msgsize < 4) && !arg_poll_char) continue;
if (msgsize >= IB_MTU * psoib_sendq_size) break;
if (msgsize >= IB_MTU * psoib_recvq_size) break;
if (arg_pscom && (unsigned)msgsize > IB_MTU_PAYLOAD) break;
/* warmup, for sync */
run_pp_c(4, 2);
t1 = getusec();
res = run_pp_c(msgsize, iloops);
t2 = getusec();
time = (double)(t2 - t1) / (iloops * 2);
throuput = msgsize / time;
if (res == 0) {
printf("%7d %8d %8.2f %8.2f\n", msgsize, iloops, time, throuput);
fflush(stdout);
} else {
printf("Error in communication...\n");
}
{
double t = (t2 - t1) / 1000;
while (t > arg_maxtime) {
loops = loops / 1.4142135;
t /= 1.4142135;
}
if (loops < 1) loops = 1;
}
}
return;
}
inline void wait(unsigned long time_in_us){
#ifdef NB_WAIT_RANDOM
time_in_us=xorshf96()%time_in_us;
#endif
unsigned long long before_time, after_time;
before_time=getusec();
do{
after_time=getusec();
} while (after_time-before_time<time_in_us);
}
void
getsucc (const chord_node &n)
{
chord_nodelistextres *res = New chord_nodelistextres ();
doRPC (n, chord_program_1, succproc, &n.x, res,
wrap (&getsucc_cb, getusec (), n, res));
}
static
void cycles_cal(void)
{
unsigned long t1, t2, rt1, rt2;
t1 = getusec();
GET_CPU_CYCLES(rt1);
/* usleep call kapm-idled and slowdown the cpu! */
while (getusec() - 1000 < t1);
GET_CPU_CYCLES(rt2);
t2 = getusec();
t2 -= t1;
rt2 -= rt1;
cycles_us = 1.0 * t2 / rt2;
printf("# %ld usec = %ld cycles, 1 usec = %f\n", t2, rt2, 1 / cycles_us);
}
void
user_args::reply (void *res)
{
//marshall result
xdrproc_t inproc = prog->tbl[procno].xdr_res;
xdrsuio x (XDR_ENCODE);
if ((!inproc) || (!inproc (x.xdrp (), res)))
fatal << "couldn't marshall result\n";
int res_len = x.uio ()->resid ();
track_reply (*prog, procno, res_len);
//stuff into a transport wrapper
dorpc_res *rpc_res = New dorpc_res (DORPC_OK);
me_->fill_node (rpc_res->resok->src);
rpc_res->resok->send_time_echo = send_time;
rpc_res->resok->results.setsize (res_len);
if (res_len > 0)
x.uio ()->copyout (rpc_res->resok->results.base ());
assert (rpc_res->status == DORPC_OK);
u_int64_t diff = getusec (true) - init_time;
track_proctime (*prog, procno, diff);
//reply
sbp->reply (rpc_res);
delete rpc_res;
delete this;
}
/*
* Функция вызывается по таймеру реального времени.
*/
static void cpu_sigalarm (int signum)
{
if (counter == 0) {
/* Первый отсчёт времени. */
t0 = getusec ();
}
++counter;
if (counter <= N)
return;
/* Последний отсчёт после N интервалов. */
t1 = getusec ();
printf ("Measured interval is %.2f msec.\n",
(t1 - t0) / 1000.0 / N);
exit (0);
}
static
void do_pp_client(void)
{
unsigned long t1, t2;
double time;
double throuput;
unsigned int msgsize;
double ms;
int res;
double loops = arg_loops;
printf("%7s %8s %8s %8s\n", "msize", "loops", "time", "throughput");
printf("%7s %8s %8s %8s\n", "[bytes]", "[cnt]", "[us/cnt]", "[MB/s]");
for (ms = 0.0/*1.4142135*/; ms < arg_maxmsize;
ms = (ms < 128) ? (ms + 1) : (ms * 1.4142135)) {
unsigned int iloops = (unsigned int)(loops + 0.5);
msgsize = (unsigned int)(ms + 0.5);
/* warmup, for sync */
run_pp_c(1, 2);
t1 = getusec();
res = run_pp_c(msgsize, iloops);
t2 = getusec();
time = (double)(t2 - t1) / (iloops * 2);
throuput = msgsize / time;
if (res == 0) {
printf("%7d %8d %8.2f %8.2f\n", msgsize, iloops, time, throuput);
fflush(stdout);
} else {
printf("Error in communication...\n");
}
{
double t = (double)(t2 - t1) / 1000;
while (t > arg_maxtime) {
loops = loops / 1.4142135;
t /= 1.4142135;
}
if (loops < 1) loops = 1;
}
}
return;
}
void
getsucc_cb (u_int64_t start, chord_node curr, chord_nodelistextres *res, clnt_stat err)
{
chord_node next;
if (err != 0 || res->status != CHORD_OK) {
aout << "failed to get a reading from " << curr << "; skipping.\n";
sequential.pop_front ();
if (sequential.size () == 0) {
fatal << "too many consecutive failures.\n";
}
next = sequential[0];
delete res;
getsucc (next);
return;
}
size_t sz = res->resok->nlist.size ();
vec<chord_node> zs;
for (size_t i = 0; i < sz; i++) {
chord_node z = make_chord_node (res->resok->nlist[i].n);
zs.push_back (z);
}
delete res;
curr = zs[0];
// ensure we talked to who we think we should be talking to.
assert (curr.x == sequential[0].x);
// Print full information for the node we just talked to
int index = curr.vnode_num;
assert (index >= 0);
char s[128];
sprintf (s, "e=%f", curr.e / Coord::PRED_ERR_MULT);
aout << format (strbuf (), curr) << " "
<< curr.coords[0] << " " << curr.coords[1] << " " << curr.coords[2] << " "
<< s << " "
<< (getusec () - start) << "\n";
if (verify) {
sequential.pop_front ();
verify_succlist (zs);
} else {
sequential = zs;
sequential.pop_front ();
}
// Out of nodes, done.
if (!sequential.size ())
exit (verify_errors == true ? 1 : 0);
next = sequential[0];
// wrapped around ring. done.
if (next.x == wellknown_ID)
exit (verify_errors == true ? 1 : 0);
getsucc (next);
}
void
getsucc (const chord_node &n)
{
chord_nodelistextres *res = New chord_nodelistextres ();
u_int64_t start = getusec ();
doRPC (n, CHORDPROC_GETSUCC_EXT, &n.x, res,
wrap (&getsucc_cb, n.x, n.r.hostname, res, start));
}
static
void run_pp_client(psdapl_con_info_t *ci)
{
unsigned long t1, t2;
double time;
double throuput;
unsigned int msgsize;
double ms;
int res;
double loops = arg_loops;
printf("%7s %8s %8s %8s\n", "msize", "loops", "time", "throughput");
printf("%7s %8s %8s %8s\n", "[bytes]", "[cnt]", "[us/cnt]", "[MB/s]");
for (ms = 1.4142135; ms < arg_maxmsize; ms = ms * 1.4142135) {
unsigned int iloops = loops;
msgsize = ms + 0.5;
/* warmup, for sync */
run_pp_c(ci, 20, 5);
t1 = getusec();
res = run_pp_c(ci, msgsize, iloops);
t2 = getusec();
time = (double)(t2 - t1) / (iloops * 2);
throuput = msgsize / time;
if (res == 0) {
printf("%7d %8d %8.2f %8.2f\n", msgsize, iloops, time, throuput);
fflush(stdout);
} else {
printf("Error in communication...\n");
}
{
double t = (t2 - t1) / 1000;
while (t > arg_maxtime) {
loops = loops / 1.4142135;
t /= 1.4142135;
}
if (loops < 1) loops = 1;
}
}
psdapl_send_eof(ci);
}
void print_stat(int newline)
{
unsigned long long now;
double dt;
now = getusec();
dt = (now - stat_time_start) / 1000000.0;
fprintf(stderr, "%10ld bytes in %7.3f seconds (%7.2f MB/s) %c",
stat_bytes_tx, dt,
stat_bytes_tx / (1024.0 * 1024.0) / dt,
newline ? '\n' : '\r');
fflush(stderr);
}
long
rpc_manager::doRPC (ptr<location> from, ptr<location> l,
const rpc_program &prog, int procno,
ptr<void> in, void *out, aclnt_cb cb,
cbtmo_t cb_tmo)
{
ref<aclnt> c = aclnt::alloc (dgram_xprt, prog,
(sockaddr *)&(l->saddr ()));
// Make sure that there is an entry in the table for this guy.
(void) lookup_host (l->address ());
u_int64_t sent = getusec ();
c->call (procno, in, out,
wrap (this, &rpc_manager::doRPCcb, cb, l, sent));
return 0;
}
void
tcp_manager::send_RPC (RPC_delay_args *args)
{
hostinfo *hi = lookup_host (args->l->address ());
if (!hi->xp) {
delaycb (0, 0, wrap (this, &tcp_manager::send_RPC_ateofcb, args));
}
else if (hi->xp->ateof()) {
hostlru.remove (hi);
hostlru.insert_tail (hi);
args->l->set_alive (false);
remove_host (hi);
delaycb (0, 0, wrap (this, &tcp_manager::send_RPC_ateofcb, args));
}
else {
hi->orpc++;
args->now = getusec ();
ptr<aclnt> c = aclnt::alloc (hi->xp, args->prog);
c->call (args->procno, args->in, args->out,
wrap (this, &tcp_manager::doRPC_tcp_cleanup, c, args));
}
}
void
rpc_manager::doRPCcb (aclnt_cb realcb, ptr<location> l, u_int64_t sent,
clnt_stat err)
{
if (err) {
nrpcfailed++;
l->set_alive (false);
} else {
nrpc++;
// Only update latency on successful RPC.
// This probably includes time needed for rexmits.
u_int64_t now = getusec ();
// prevent overflow, caused by time reversal
if (now >= sent) {
u_int64_t lat = now - sent;
update_latency (NULL, l, lat);
} else {
warn << "*** Ignoring timewarp: sent " << sent
<< " > now " << now << "\n";
}
}
(realcb) (err);
}
void PassMgr::performScalarOpt(OptCtx & oc)
{
TTab<Pass*> opt_tab;
List<Pass*> passlist;
SimpCtx simp;
if (g_do_gvn) { registerPass(PASS_GVN); }
if (g_do_pre) {
//Do PRE individually.
//Since it will incur the opposite effect with Copy-Propagation.
Pass * pre = registerPass(PASS_PRE);
pre->perform(oc);
ASSERT0(verifyIRandBB(m_ru->get_bb_list(), m_ru));
}
if (g_do_dce) {
IR_DCE * dce = (IR_DCE*)registerPass(PASS_DCE);
passlist.append_tail(dce);
if (g_do_dce_aggressive) {
dce->set_elim_cfs(true);
}
}
bool in_ssa_form = false;
IR_SSA_MGR * ssamgr =
(IR_SSA_MGR*)(m_ru->get_pass_mgr()->queryPass(PASS_SSA_MGR));
if (ssamgr != NULL && ssamgr->is_ssa_constructed()) {
in_ssa_form = true;
}
if (!in_ssa_form) {
//RP can reduce the memory operations and
//improve the effect of PR SSA, so perform
//RP before SSA construction.
//TODO: Do SSA renaming when after register promotion done.
if (g_do_rp) {
//First RP.
passlist.append_tail(registerPass(PASS_RP));
}
}
if (g_do_cp) {
IR_CP * pass = (IR_CP*)registerPass(PASS_CP);
pass->set_prop_kind(CP_PROP_SIMPLEX);
passlist.append_tail(pass);
}
if (g_do_rp) {
//Second RP.
passlist.append_tail(registerPass(PASS_RP));
}
if (g_do_gcse) {
passlist.append_tail(registerPass(PASS_GCSE));
}
if (g_do_lcse) {
passlist.append_tail(registerPass(PASS_LCSE));
}
if (g_do_rce) {
passlist.append_tail(registerPass(PASS_RCE));
}
if (g_do_dse) {
passlist.append_tail(registerPass(PASS_DSE));
}
if (g_do_licm) {
passlist.append_tail(registerPass(PASS_LICM));
}
if (g_do_ivr) {
passlist.append_tail(registerPass(PASS_IVR));
}
if (g_do_loop_convert) {
passlist.append_tail(registerPass(PASS_LOOP_CVT));
}
bool change;
UINT count = 0;
BBList * bbl = m_ru->get_bb_list();
IR_CFG * cfg = m_ru->get_cfg();
UNUSED(cfg);
do {
change = false;
for (Pass * pass = passlist.get_head();
pass != NULL; pass = passlist.get_next()) {
CHAR const* passname = pass->get_pass_name();
ASSERT0(verifyIRandBB(bbl, m_ru));
ULONGLONG t = getusec();
bool doit = pass->perform(oc);
appendTimeInfo(passname, getusec() - t);
if (doit) {
change = true;
ASSERT0(verifyIRandBB(bbl, m_ru));
ASSERT0(cfg->verify());
}
RefineCtx rc;
m_ru->refineBBlist(bbl, rc);
ASSERT0(m_ru->verifyRPO(oc));
}
count++;
} while (change && count < 20);
ASSERT0(!change);
if (g_do_lcse) {
IR_LCSE * lcse = (IR_LCSE*)registerPass(PASS_LCSE);
lcse->set_enable_filter(false);
ULONGLONG t = getusec();
lcse->perform(oc);
t = getusec() - t;
appendTimeInfo(lcse->get_pass_name(), t);
}
if (g_do_rp) {
IR_RP * r = (IR_RP*)registerPass(PASS_RP);
ULONGLONG t = getusec();
r->perform(oc);
appendTimeInfo(r->get_pass_name(), getusec() - t);
}
}
void
do_pp(void)
{
con_info_t con;
IB_lid_t remote_lid; /* remote peer's LID */
IB_wqpn_t remote_qpn; /* remote peer's QPN */
if (psib_init_con(&default_hca, &default_port, &con)) goto err_init_con;
printf("Local LID / QP : 0x%04x 0x%06x\n",
con.lid,
con.qp_prop.qp_num);
{
int rlid, rqpn;
while (1) {
printf("Remote LID and QP?\n");
fflush(stdout);
if (scanf("%x %x", &rlid, &rqpn) == 2) break;
printf("wrong format...\n");
}
remote_lid = rlid;
remote_qpn = rqpn;
}
if (psib_connect_con(&con, remote_lid, remote_qpn)) goto err_connect_con;
/* Wait until both sides reach rts */
sleep(2);
if (arg_client) {
unsigned long t1, t2;
double time;
double throuput;
unsigned int msgsize;
double ms;
int res;
printf("%5s %8s %6s %6s\n", "msize", "loops", "time", "throughput");
for (ms = 1.4142135; ms < IB_MTU_PAYLOAD - 1; ms = ms * 1.4142135) {
// for (ms = 1.4142135; ms < IB_MTU_PAYLOAD - 1; ms = ms +1) {
msgsize = ms + 0.5;
/* warmup, for sync */
run_pp(&default_hca, &con, 2, 1);
t1 = getusec();
res = run_pp(&default_hca, &con, arg_loops, msgsize);
t2 = getusec();
time = (double)(t2 - t1) / (arg_loops * 2);
throuput = msgsize / time;
if (res == 0) {
printf("%5d %8d %6.2f %6.2f\n", msgsize, arg_loops, time, throuput);
fflush(stdout);
} else {
printf("Error in communication: %m\n");
}
}
} else {
printf("Server started.\n");
run_pp_server(&default_hca, &con);
}
return;
/* --- */
err_init_con:
printf("psib_init_con() failed : %s\n", psib_err_str);
exit(1);
err_connect_con:
printf("psib_connect_con() failed : %s\n", psib_err_str);
exit(1);
}
void doClient(void)
{
int forward_id;
ps_recv_info_t rinfo;
ps_send_info_t sinfo;
FILE *output = NULL;
PSP_PortH_t porth;
char *buf, *buf2;
buf = malloc(arg_maxmsize);
if (!buf) { perror("malloc(buf)"); exit(1); }
buf2 = malloc(arg_maxmsize);
if (!buf2) { perror("malloc(buf2)"); exit(1); }
output = stdout;
if (arg_ofile) {
output = fopen(arg_ofile, "w");
if (!output) {
fprintf(stderr, "Cant open file '%s' for writing : %s\n",
arg_ofile, strerror(errno));
exit(1);
}
} else if (arg_ocmd) {
output = popen(arg_ocmd, "w");
if (!output) {
fprintf(stderr, "Cant start output command '%s' : %s\n",
arg_icmd, strerror(errno));
exit(1);
}
}
porth = start_client(&forward_id);
ps_recv_info_init(&rinfo, porth);
ps_send_info_init(&sinfo, porth, forward_id);
PSP_StopListen(porth);
stat_time_start = getusec();
while (1) {
int len;
char *tmp;
len = ps_recv(&rinfo, buf, arg_maxmsize);
ps_send(&sinfo, buf, len);
if (len <= 0) break;
assert(fwrite(buf, 1, len, output) == (unsigned) len);
tmp = buf; buf = buf2; buf2 = tmp;
if (timer_called) {
if (arg_manual) print_stat(0);
timer_called = 0;
}
}
if (arg_ofile) {
fclose(output);
} else if (arg_ocmd) {
pclose(output);
}
ps_recv_close(&rinfo);
ps_send_close(&sinfo);
free(buf2);
free(buf);
}
void doServer(void)
{
int forward_id, numClients;
ps_send_info_t sinfo;
FILE *input = NULL;
PSnodes_ID_t node;
PSP_PortH_t porth;
char *buf, *buf2;
buf = malloc(arg_maxmsize);
if (!buf) { perror("malloc(buf)"); exit(1); }
buf2 = malloc(arg_maxmsize);
if (!buf2) { perror("malloc(buf2)"); exit(1); }
input = stdin;
if (arg_ifile) {
input = fopen(arg_ifile, "r");
if (!input) {
fprintf(stderr, "Cant open file '%s' for reading : %s\n",
arg_ifile, strerror(errno));
exit(1);
}
} else if (arg_icmd) {
input = popen(arg_icmd, "r");
if (!input) {
fprintf(stderr, "Cant start input command '%s' : %s\n",
arg_icmd, strerror(errno));
exit(1);
}
}
porth = start_server();
if (arg_manual) {
numClients = arg_manual;
} else {
int clientRank = 1;
if (arg_hosts) {
nodeList = getNLFromHosts(arg_hosts);
} else if (arg_nodes) {
nodeList = getNLFromNodes(arg_nodes);
} else {
nodeList = getNLFromNodes("all");
}
if (!nodeList && !arg_manual) {
fprintf(stderr, "Unknown clients\n");
exit(1);
}
/* Start clients */
for (node=0; node<PSC_getNrOfNodes(); node++) {
if (node == PSC_getMyID()) continue;
if (nodeList[node]) {
int ret = PSE_spawnAdmin(node, clientRank,
rem_argc, rem_argv, 0);
if (!ret) clientRank++;
}
}
numClients = clientRank - 1;
if (arg_verbose)
fprintf(stderr, "Distribute to %d clients\n", numClients);
}
forward_id = assign_clients(porth, numClients);
PSP_StopListen(porth);
ps_send_info_init(&sinfo, porth, forward_id);
stat_time_start = getusec();
// read from stdin, forward to forward_id
while (1) {
int len;
char *tmp;
len = read(fileno(input), buf, arg_maxmsize);
if (len <= 0) break;
ps_send(&sinfo, buf, len);
// swap buffers (ps_send use PSP_ISend. We can read more
// data, while we transmit the old data.)
tmp = buf; buf = buf2; buf2 = tmp;
if (timer_called) {
print_stat(arg_cp ? 1 : 0);
timer_called = 0;
}
}
if (arg_ifile) {
fclose(input);
} else if (arg_icmd) {
pclose(input);
}
// Send eof:
ps_send(&sinfo, NULL, 0);
ps_send_close(&sinfo);
free(buf);
free(buf2);
}
chord::chord (str host, int port,
vnode_producer_t p, int nvnodes,
int max_cache) :
max_vnodes (0),
myname (host),
myport (port),
fd_dgram (-1),
fd_stream (-1),
x_dgram (NULL),
nrcv (NULL),
rpcm (NULL),
locations (NULL)
{
bool ok (false);
ok = Configurator::only ().get_int ("chord.max_vnodes", max_vnodes);
assert (ok);
if (nvnodes > max_vnodes)
fatal << "Requested more than allowed vnodes: "
<< nvnodes << ">" << max_vnodes << "\n";
if (nvnodes < 1) {
warn << "Creating at least one vnode.\n";
nvnodes = 1;
}
str rpcstr;
ok = Configurator::only ().get_str ("chord.rpc_mode", rpcstr);
assert (ok);
chord_rpc_style = CHORD_RPC_STP;
if (rpcstr == "tcp" || rpcstr == "TCP")
chord_rpc_style = CHORD_RPC_SFST;
else if (rpcstr == "udp" || rpcstr == "UDP")
chord_rpc_style = CHORD_RPC_SFSU;
nrcv = New refcounted<u_int32_t>;
*nrcv = 0;
switch (chord_rpc_style) {
case CHORD_RPC_STP:
rpcm = New refcounted<stp_manager> (nrcv);
break;
case CHORD_RPC_SFSU:
rpcm = New refcounted<rpc_manager> (nrcv);
break;
case CHORD_RPC_SFST:
case CHORD_RPC_SFSBT:
rpcm = New refcounted<tcp_manager> (nrcv);
break;
default:
fatal << "bad chord_rpc_style value: " << chord_rpc_style << "\n";
}
/* In case myport == 0, need to initialize to something in order
* to create chordIDs during vnode initialization */
myport = initxprt (myport, SOCK_DGRAM, &fd_dgram);
myport = initxprt (myport, SOCK_STREAM, &fd_stream);
warnx << "chord: running on " << myname << ":" << myport << "\n";
locations = New refcounted<locationtable> (max_cache);
srandom ((unsigned int) (getusec() & 0xFFFFFFFF));
for (int i = 0; i < nvnodes; i++)
{
chordID newID = make_chordID (myname, myport, i);
warnx << gettime () << ": creating new vnode: " << newID << "\n";
Coord coords;
ptr<location> l = locations->insert (newID, myname, myport,
i, coords, 30, 0, 1, true);
assert (l);
locations->pin (newID);
ptr<vnode> vnodep = (*p) (mkref (this), rpcm, l);
vnodes.insert (newID, vnodep);
vlist.push_back (vnodep);
}
}
