int main(int argc, char** argv)
{
init_jvm();
::org::mpisws::p2p::testing::transportlayer::BandwidthMeasuringTLTest::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::org::mpisws::p2p::testing::transportlayer::peerreview::PRInconsistent1::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::org::mpisws::p2p::testing::transportlayer::peerreview::PRRegressionTest::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::pastry::testing::IdRangeUnit::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::p2p::util::testing::StringCacheUnit::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::org::mpisws::p2p::testing::filetransfer::EncryptedFileTest::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::p2p::util::testing::SecurityUtilsUnit::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::pastry::testing::rendezvous::DistTutorial::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::pastry::standard::StandardAddress::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::p2p::util::BloomFilter::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::p2p::util::testing::RedBlackMapUnit::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::tutorial::gtitm::DirectTutorial::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::tutorial::lesson1::DistTutorial::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::pastry::testing::DirectPastryPingTest::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::org::mpisws::p2p::testing::transportlayer::SSLTestNoClientAuth::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::org::mpisws::p2p::testing::transportlayer::RapidRebind::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::tutorial::sendfile::Tutorial::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::p2p::past::testing::DistPastTest::main(make_args(argc, argv));
return 0;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::persistence::testing::MemoryStorageTest::main(make_args(argc, argv));
return 0;
}
static int gdlm_mount(char *table_name, char *host_data,
lm_callback_t cb, void *cb_data,
unsigned int min_lvb_size, int flags,
struct lm_lockstruct *lockstruct,
struct kobject *fskobj)
{
struct gdlm_ls *ls;
int error = -ENOMEM, nodir = 0;
if (min_lvb_size > GDLM_LVB_SIZE)
goto out;
ls = init_gdlm(cb, cb_data, flags, table_name);
if (!ls)
goto out;
error = make_args(ls, host_data, &nodir);
if (error)
goto out;
error = gdlm_init_threads(ls);
if (error)
goto out_free;
error = gdlm_kobject_setup(ls, fskobj);
if (error)
goto out_thread;
error = dlm_new_lockspace(ls->fsname, strlen(ls->fsname),
&ls->dlm_lockspace,
DLM_LSFL_FS | (nodir ? DLM_LSFL_NODIR : 0),
GDLM_LVB_SIZE);
if (error) {
log_error("dlm_new_lockspace error %d", error);
goto out_kobj;
}
dlm_posix_set_fsid(ls->dlm_lockspace, ls->id);
lockstruct->ls_jid = ls->jid;
lockstruct->ls_first = ls->first;
lockstruct->ls_lockspace = ls;
lockstruct->ls_ops = &gdlm_ops;
lockstruct->ls_flags = 0;
lockstruct->ls_lvb_size = GDLM_LVB_SIZE;
return 0;
out_kobj:
gdlm_kobject_release(ls);
out_thread:
gdlm_release_threads(ls);
out_free:
kfree(ls);
out:
return error;
}
VarRefNewObjectNode* VarRefNode::globalMakeNewCall(AbstractQoreNode* args) {
assert(type == VT_GLOBAL);
if (ref.var->hasTypeInfo()) {
QoreParseTypeInfo* pti = ref.var->copyParseTypeInfo();
VarRefNewObjectNode* rv = new VarRefNewObjectNode(takeName(), ref.var, make_args(args), pti ? 0 : ref.var->getTypeInfo(), pti);
deref();
return rv;
}
return 0;
}
pthread_t *start_worker(int **array, int lo, int hi, worker_pool *wp)
{
pthread_t *th = NULL;
args_t *args = NULL;
if(request_worker(wp)){
HANDLE(!(th = malloc(sizeof(pthread_t))));
args = make_args(array, lo, hi, wp);
HANDLE(pthread_create(th, NULL, mergesort_p, args));
}
return th;
}
int main() {
char buf[80];
printf("Enter the password.\n");
readuntil(STDIN_FILENO, buf, 80, '\n');
// meh.
if (strlen(buf) != 30) { puts("Wrong! :("); return; }
thunk *t = make_thunk(verify);
thunk *a = make_thunk(id);
a->value = buf;
a->computed = 1;
t->arguments = make_args(a);
if (t->compute(t)) {
puts("Congratulations! :)");
} else {
puts("Wrong! :(");
}
}
thunk *burrows_wheeler(thunk *t) {
if (t->computed) return t->value;
thunk *a = make_thunk(string_length);
a->arguments = make_args(t->arguments[0]);
thunk *b = make_thunk(rotate_by_all);
b->arguments = malloc(sizeof(thunk *) * 2);
b->arguments[0] = a->arguments[0];
b->arguments[1] = a;
thunk *c = make_thunk(sorted);
c->arguments = malloc(sizeof(thunk *) * 2);
c->arguments[0] = b;
c->arguments[1] = a;
thunk *d = make_thunk(get_last);
d->arguments = malloc(sizeof(thunk *) * 2);
d->arguments[0] = c;
d->arguments[1] = a;
t->computed = 1;
t->value = d;
return d;
}
void csort(int *array, int size)
{
/* int tmp[RANGE + 1] = {0}; */
pthread_t *workers[WORKER_THREADS];
args_t *args[WORKER_THREADS];
int chunk_size = size / WORKER_THREADS;
int end = 0;
int i;
/* initialize the tmp array */
for(i = 0; i < RANGE + 1; i++){
sem_init(&tmp[i], 0, 0);
}
/* partition the work */
for(i = 0; i < WORKER_THREADS; i ++){
end = i == WORKER_THREADS - 1 ? size : (i + 1) * chunk_size;
args[i] = make_args(&array, i * chunk_size, end);
workers[i] = malloc(sizeof(pthread_t));
HANDLE(pthread_create(workers[i], NULL, populate_tmp_p, args[i]));
}
/* wait for everything to finish */
for(i = 0; i < WORKER_THREADS; i++){
pthread_join(*workers[i], NULL);
}
/* writeback, sequentially */
unroll_tmp(&array, RANGE);
/* free everything */
// for(i = 0; i < WORKER_THREADS; i++){
// free_args(args[i]);
/* pthread_destroy(workers[i]); */
// }
}
//execute a command
int doCmd(char *cs) {
//buffers for args and arg vector
//NOTE: this limits the maximum # of arguments
// and total length of all arguments
char args[50];
char *argv[10];
unsigned short argc;
int i;
//split string into arguments
argc=make_args(argv,cs,args);
//search for command
for(i=0; cmd_tbl[i].name!=NULL; i++) {
//look for a match
if(!strcmp(cmd_tbl[i].name,argv[0])) {
//match found, run command and return
return cmd_tbl[i].cmd(argv,argc);
}
}
//unknown command, print help message
printf("unknown command \'%s\'\r\n",argv[0]);
helpCmd(NULL,0);
//unknonwn command, return error
return 1;
}
int main (int argc, char ** argv) {
int n;
char * nargv[numDbgArgs];
int fdtoWeb,fdfrmWeb,fdtoDbg,fdfrmDgb,pipefd[2];
char buf[BUFFSIZE],line[BUFFSIZE],toServer[MaxPipeName],fromServer[MaxPipeName];
signal(SIGPIPE, catch_sigpipe);
if ((argc < 2 )|| (argc >=3)){
perror("usage: debugger idcode");
exit(1);
}
/*
//create input pipe from webserver
sprintf(fromServer,"%s%s%s",logdir,argv[1],"OUT");
unlink(fromServer);
if (-1 == mkfifo(fromServer,S_IRWXU)) {
perror("Error, could not make fifo\n");
}
//create output pipe to webserver
sprintf(toServer,"%s%s%s",logdir,argv[1],"IN");
unlink(toServer);
if (-1 == mkfifo(toServer,S_IRWXU)) {
perror("Error, could not make fifo\n");
}
if ((fdfrmWeb = open(fromServer,O_RDONLY)) == -1) {
perror("cannot open fifo from server");
exit(1);
}
if ((fdtoWeb = open(toServer,O_WRONLY)) == -1) {
perror("cannot open fifo to server");
exit(1);
}
//create pipes to debugger
if(pipe(pipefd) == -1) { //perhaps pipe(pipefd,O_NONBLOCK)
perror("Pipe 1 creation failed");
exit(1);
}
*/
int i;
char c;make_args(argv[1],nargv);
child_pid=launch_debugger(nargv,pipefd);
printf("child_pid=%d\n",child_pid);
fflush(stdout);
// while(1){
/*
if ((n=read(fdfrmWeb,line,BUFFSIZE))){
line[n]=0;
n=sprintf(buf,"%d-%s%s",n,"debugger:",line);
if (write(1,buf,n) != n) {
printf("cp: write error on file stdout\n");
fflush(stdout);
exit(1);
}
if (write(fdtoWeb,buf,n) != n) {
perror("fdtoWeb write error");
}
}
else{
printf("empty read\n");
close(fdtoWeb);
close(fdfrmWeb);
n=0;
if ((fdfrmWeb = open(fromServer,O_RDONLY)) == -1) {
perror("cannot open fifo from server");
exit(1);
}
if ((fdtoWeb = open(toServer,O_WRONLY)) == -1) {
perror("cannot open fifo to server");
exit(1);
}
}
*/
while (1){
i=0;
while ((c=getchar())!='\n'){
line[i++]=c;
}
line[i]=c;
write(pipefd[1],line,i+1);
if ((n=read(pipefd[0],line,BUFFSIZE))){
line[n]=0;
}
printf("%s",line);
fflush(stdout);
}
exit(0);
}
// for checking for new object calls
AbstractQoreNode* VarRefDeclNode::makeNewCall(AbstractQoreNode* args) {
VarRefNewObjectNode* rv = new VarRefNewObjectNode(loc, takeName(), typeInfo, takeParseTypeInfo(), make_args(args), type);
deref();
return rv;
}
int main(int argc, char** argv)
{
init_jvm();
::rice::pastry::direct::proximitygenerators::SphereNetworkProximityGenerator::main(make_args(argc, argv));
return 0;
}
static int do_batch(int argc, char **argv)
{
char buf[BATCH_LINE_LEN_MAX], contline[BATCH_LINE_LEN_MAX];
char *n_argv[BATCH_ARG_NB_MAX];
unsigned int lines = 0;
int n_argc;
FILE *fp;
char *cp;
int err;
int i;
if (argc < 2) {
p_err("too few parameters for batch");
return -1;
} else if (!is_prefix(*argv, "file")) {
p_err("expected 'file', got: %s", *argv);
return -1;
} else if (argc > 2) {
p_err("too many parameters for batch");
return -1;
}
NEXT_ARG();
if (!strcmp(*argv, "-"))
fp = stdin;
else
fp = fopen(*argv, "r");
if (!fp) {
p_err("Can't open file (%s): %s", *argv, strerror(errno));
return -1;
}
if (json_output)
jsonw_start_array(json_wtr);
while (fgets(buf, sizeof(buf), fp)) {
cp = strchr(buf, '#');
if (cp)
*cp = '\0';
if (strlen(buf) == sizeof(buf) - 1) {
errno = E2BIG;
break;
}
/* Append continuation lines if any (coming after a line ending
* with '\' in the batch file).
*/
while ((cp = strstr(buf, "\\\n")) != NULL) {
if (!fgets(contline, sizeof(contline), fp) ||
strlen(contline) == 0) {
p_err("missing continuation line on command %d",
lines);
err = -1;
goto err_close;
}
cp = strchr(contline, '#');
if (cp)
*cp = '\0';
if (strlen(buf) + strlen(contline) + 1 > sizeof(buf)) {
p_err("command %d is too long", lines);
err = -1;
goto err_close;
}
buf[strlen(buf) - 2] = '\0';
strcat(buf, contline);
}
n_argc = make_args(buf, n_argv, BATCH_ARG_NB_MAX, lines);
if (!n_argc)
continue;
if (n_argc < 0)
goto err_close;
if (json_output) {
jsonw_start_object(json_wtr);
jsonw_name(json_wtr, "command");
jsonw_start_array(json_wtr);
for (i = 0; i < n_argc; i++)
jsonw_string(json_wtr, n_argv[i]);
jsonw_end_array(json_wtr);
jsonw_name(json_wtr, "output");
}
err = cmd_select(cmds, n_argc, n_argv, do_help);
if (json_output)
jsonw_end_object(json_wtr);
if (err)
goto err_close;
lines++;
}
if (errno && errno != ENOENT) {
p_err("reading batch file failed: %s", strerror(errno));
err = -1;
} else {
if (!json_output)
printf("processed %d commands\n", lines);
err = 0;
}
err_close:
if (fp != stdin)
fclose(fp);
if (json_output)
jsonw_end_array(json_wtr);
return err;
}
