int
main(int argc, char **argv)
{
tree t, p;
si_t si = make_si(100);
FILE *fp = stdin;
vihashl localtree_ht = make_vihashl(1000);
si_index root = si_string_index(si, root_label);
assert(root == 1);
if (argc != 1) {
fprintf(stderr, "%s < trees > local-tree-counts\n", argv[0]);
exit(EXIT_FAILURE);
}
/* read the trees and save the local tree counts */
while ((t = readtree_root(fp, si))) {
/* si_display(si, stdout);
* displaytree(tree, si, 0);
* printf("\n");
*/
p = collapse_identical_unary(t); free_tree(t);
count_local_trees(p, localtree_ht);
free_tree(p);
}
write_local_trees(localtree_ht, si, root);
si_free(si);
free_vihashl(localtree_ht);
/* assert(mmm_bytes_allocated == 0); */
exit(0);
}
static void ti_enumerate_thread_stack(TIEnv* ti_env, StackIterator* si)
{
ASSERT_NO_INTERPRETER
TIIterationState *state = ti_env->iteration_state;
state->depth = 0;
while (!si_is_past_end(si)) {
CodeChunkInfo* cci = si_get_code_chunk_info(si);
if (cci) {
state->method = (jmethodID)cci->get_method();
state->root_kind = JVMTI_HEAP_ROOT_STACK_LOCAL;
// FIXME: set up frame base (platform dependent!)
cci->get_jit()->get_root_set_from_stack_frame(cci->get_method(), 0, si_get_jit_context(si));
} else {
state->method = (jmethodID)m2n_get_method(si_get_m2n(si));
state->root_kind = JVMTI_HEAP_ROOT_JNI_LOCAL;
oh_enumerate_handles(m2n_get_local_handles(si_get_m2n(si)));
}
state->depth += 1;
si_goto_previous(si);
}
si_free(si);
}
/* load service paths */
static int config_service(void)
{
struct service_info si;
int ret;
memset(&si, 0, sizeof(si));
ret = csv_load("services.csv", &si, si_field, si_row_end);
si_free(&si);
return ret;
}
static int si_row_end(void *p, unsigned row)
{
struct service_info *si = p;
struct domain *dom;
assert(si != NULL);
if (!row) /* ignore first row */
return 0;
if (!si->domain || !si->path_prefix || !si->module)
return -1;
dom = dom_find(si->domain);
if (!dom)
return -1;
if (se_add(dom, si->path_prefix, si->module))
return -1;
si_free(si);
return 0;
}
/** Frees self and self only. */
SiList * silist_free_self(SiList * self) {
return si_free(self);
}
SiTerm * siterm_free(SiTerm * term) {
return si_free(term);
}
/*
* Something (e.g. another driver) has called us
* with a periph and a scsi-specific ioctl to perform,
* better try. If user-level type command, we must
* still be running in the context of the calling process
*/
int
scsipi_do_ioctl(struct scsipi_periph *periph, dev_t dev, u_long cmd,
void *addr, int flag, struct lwp *l)
{
int error;
SC_DEBUG(periph, SCSIPI_DB2, ("scsipi_do_ioctl(0x%lx)\n", cmd));
if (addr == NULL)
return EINVAL;
/* Check for the safe-ness of this request. */
switch (cmd) {
case OSCIOCIDENTIFY:
case SCIOCIDENTIFY:
break;
case SCIOCCOMMAND:
if ((((scsireq_t *)addr)->flags & SCCMD_READ) == 0 &&
(flag & FWRITE) == 0)
return (EBADF);
break;
default:
if ((flag & FWRITE) == 0)
return (EBADF);
}
switch (cmd) {
case SCIOCCOMMAND: {
scsireq_t *screq = (scsireq_t *)addr;
struct scsi_ioctl *si;
int len;
si = si_get();
si->si_screq = *screq;
si->si_periph = periph;
len = screq->datalen;
if (len) {
si->si_iov.iov_base = screq->databuf;
si->si_iov.iov_len = len;
si->si_uio.uio_iov = &si->si_iov;
si->si_uio.uio_iovcnt = 1;
si->si_uio.uio_resid = len;
si->si_uio.uio_offset = 0;
si->si_uio.uio_rw =
(screq->flags & SCCMD_READ) ? UIO_READ : UIO_WRITE;
if ((flag & FKIOCTL) == 0) {
si->si_uio.uio_vmspace = l->l_proc->p_vmspace;
} else {
UIO_SETUP_SYSSPACE(&si->si_uio);
}
error = physio(scsistrategy, &si->si_bp, dev,
(screq->flags & SCCMD_READ) ? B_READ : B_WRITE,
periph->periph_channel->chan_adapter->adapt_minphys,
&si->si_uio);
} else {
/* if no data, no need to translate it.. */
si->si_bp.b_flags = 0;
si->si_bp.b_data = 0;
si->si_bp.b_bcount = 0;
si->si_bp.b_dev = dev;
si->si_bp.b_proc = l->l_proc;
scsistrategy(&si->si_bp);
error = si->si_bp.b_error;
}
*screq = si->si_screq;
si_free(si);
return (error);
}
case SCIOCDEBUG: {
int level = *((int *)addr);
SC_DEBUG(periph, SCSIPI_DB3, ("debug set to %d\n", level));
periph->periph_dbflags = 0;
if (level & 1)
periph->periph_dbflags |= SCSIPI_DB1;
if (level & 2)
periph->periph_dbflags |= SCSIPI_DB2;
if (level & 4)
periph->periph_dbflags |= SCSIPI_DB3;
if (level & 8)
periph->periph_dbflags |= SCSIPI_DB4;
return (0);
}
case SCIOCRECONFIG:
case SCIOCDECONFIG:
return (EINVAL);
case SCIOCIDENTIFY: {
struct scsi_addr *sca = (struct scsi_addr *)addr;
switch (scsipi_periph_bustype(periph)) {
case SCSIPI_BUSTYPE_SCSI:
sca->type = TYPE_SCSI;
sca->addr.scsi.scbus =
device_unit(device_parent(periph->periph_dev));
sca->addr.scsi.target = periph->periph_target;
sca->addr.scsi.lun = periph->periph_lun;
return (0);
case SCSIPI_BUSTYPE_ATAPI:
sca->type = TYPE_ATAPI;
sca->addr.atapi.atbus =
device_unit(device_parent(periph->periph_dev));
sca->addr.atapi.drive = periph->periph_target;
return (0);
}
return (ENXIO);
}
#if defined(COMPAT_12) || defined(COMPAT_FREEBSD)
/* SCIOCIDENTIFY before ATAPI staff merge */
case OSCIOCIDENTIFY: {
struct oscsi_addr *sca = (struct oscsi_addr *)addr;
switch (scsipi_periph_bustype(periph)) {
case SCSIPI_BUSTYPE_SCSI:
sca->scbus =
device_unit(device_parent(periph->periph_dev));
sca->target = periph->periph_target;
sca->lun = periph->periph_lun;
return (0);
}
return (ENODEV);
}
#endif
default:
return (ENOTTY);
}
#ifdef DIAGNOSTIC
panic("scsipi_do_ioctl: impossible");
#endif
}
jvmtiError JNICALL
jvmtiGetLocalLong(jvmtiEnv* env,
jthread thread,
jint depth,
jint slot,
jlong* value_ptr)
{
TRACE("GetLocalLong called");
SuspendEnabledChecker sec;
/*
* Check given env & current phase.
*/
jvmtiPhase phases[] = {JVMTI_PHASE_LIVE};
CHECK_EVERYTHING();
CHECK_CAPABILITY(can_access_local_variables);
// check error condition: JVMTI_ERROR_INVALID_THREAD
// check error condition: JVMTI_ERROR_THREAD_NOT_ALIVE
// check error condition: JVMTI_ERROR_ILLEGAL_ARGUMENT
// check error condition: JVMTI_ERROR_NULL_POINTER
jvmtiError err = GetLocal_checkArgs(env, &thread, depth, slot, value_ptr);
if (err != JVMTI_ERROR_NONE)
return err;
bool thread_suspended = false;
// Suspend thread before getting stacks
vm_thread_t vm_thread;
if (NULL != thread)
{
// Check that this thread is not current
vm_thread = jthread_get_vm_thread_ptr_safe(thread);
if (vm_thread != p_TLS_vmthread)
{
IDATA UNREF status = hythread_suspend_other((hythread_t)vm_thread);
assert(TM_ERROR_NONE == status);
thread_suspended = true;
}
}
else
vm_thread = p_TLS_vmthread;
if (interpreter_enabled())
// check error condition: JVMTI_ERROR_INVALID_SLOT
// check error condition: JVMTI_ERROR_OPAQUE_FRAME
// check error condition: JVMTI_ERROR_NO_MORE_FRAMES
// TODO: check error condition: JVMTI_ERROR_TYPE_MISMATCH
err = interpreter.interpreter_ti_getLocal64(env,
vm_thread, depth, slot, value_ptr);
else
{
GET_JIT_FRAME_CONTEXT;
tmn_suspend_disable();
OpenExeJpdaError result = jit->get_local_var(method, jfc, slot,
VM_DATA_TYPE_INT64, value_ptr);
si_free(si);
tmn_suspend_enable();
err = jvmti_translate_jit_error(result);
}
if (thread_suspended)
hythread_resume((hythread_t)vm_thread);
return err;
}
/**
* General function to set value of local variable.
* @param var_type type of the local variable
* @param p_value pointer to the new variable value
*/
static jvmtiError set_local(jvmtiEnv* env,
jthread thread,
jint depth,
jint slot,
VM_Data_Type var_type,
void* p_value)
{
SuspendEnabledChecker sec;
/*
* Check given env & current phase.
*/
jvmtiPhase phases[] = {JVMTI_PHASE_LIVE};
CHECK_EVERYTHING();
CHECK_CAPABILITY(can_access_local_variables);
// check error condition: JVMTI_ERROR_INVALID_THREAD
// check error condition: JVMTI_ERROR_THREAD_NOT_ALIVE
// check error condition: JVMTI_ERROR_ILLEGAL_ARGUMENT
jvmtiError err = GetLocal_checkArgs(env, &thread, depth, slot, p_value);
if (err != JVMTI_ERROR_NONE)
return err;
// check error condition: JVMTI_ERROR_INVALID_OBJECT
if (VM_DATA_TYPE_CLASS == var_type && ! is_valid_object(env, *(jobject*) p_value))
return JVMTI_ERROR_INVALID_OBJECT;
bool thread_suspended = false;
// Suspend thread before getting stacks
vm_thread_t vm_thread;
if (NULL != thread)
{
// Check that this thread is not current
vm_thread = jthread_get_vm_thread_ptr_safe(thread);
if (vm_thread != p_TLS_vmthread)
{
IDATA UNREF status = hythread_suspend_other((hythread_t)vm_thread);
assert(TM_ERROR_NONE == status);
thread_suspended = true;
}
}
else
vm_thread = p_TLS_vmthread;
if (interpreter_enabled())
{
// TODO: check error condition: JVMTI_ERROR_INVALID_SLOT
// TODO: check error condition: JVMTI_ERROR_TYPE_MISMATCH
// TODO: check error condition: JVMTI_ERROR_OPAQUE_FRAME
// TODO: check error condition: JVMTI_ERROR_NO_MORE_FRAMES
switch (var_type) {
case VM_DATA_TYPE_CLASS:
err = interpreter.interpreter_ti_setObject(env, vm_thread,
depth, slot, *(jobject*) p_value);
break;
case VM_DATA_TYPE_INT32:
case VM_DATA_TYPE_F4:
err = interpreter.interpreter_ti_setLocal32(env, vm_thread,
depth, slot, *(int*) p_value);
break;
case VM_DATA_TYPE_INT64:
case VM_DATA_TYPE_F8:
err = interpreter.interpreter_ti_setLocal64(env, vm_thread,
depth, slot, *(int64*) p_value);
break;
default:
DIE(("Error: unrecognized local variable type"));
}
}
else
{
GET_JIT_FRAME_CONTEXT;
tmn_suspend_disable();
OpenExeJpdaError result;
switch (var_type) {
case VM_DATA_TYPE_CLASS:
if (NULL != *(jobject*) p_value)
result = jit->set_local_var(method, jfc, slot,
VM_DATA_TYPE_CLASS, &(*(ObjectHandle*) p_value)->object);
else
{
ManagedObject *n = (ManagedObject *)VM_Global_State::loader_env->managed_null;
result = jit->set_local_var(method, jfc, slot,
VM_DATA_TYPE_CLASS, &n);
}
break;
case VM_DATA_TYPE_INT32:
case VM_DATA_TYPE_F4:
case VM_DATA_TYPE_INT64:
case VM_DATA_TYPE_F8:
result = jit->set_local_var(method, jfc, slot, var_type,
p_value);
break;
default:
DIE(("Error: unrecognized local variable type"));
}
si_free(si);
tmn_suspend_enable();
err = jvmti_translate_jit_error(result);
}
if (thread_suspended)
hythread_resume((hythread_t)vm_thread);
return err;
}
int
main(int argc, char **argv)
{
si_t si = make_si(1024);
FILE *grammarfp = stdin;
FILE *yieldfp;
FILE *tracefp = stderr; /* set this to NULL to stop trace output */
FILE *summaryfp = stderr; /* set this to NULL to stop parse stats */
grammar g0, g = NULL;
int maxlen = 0, minits = 0, maxits = 0;
FLOAT stoptol = 1e-7;
int nanneal = 0, randseed = 97;
FLOAT rule_bias_default = 0;
FLOAT annealstart = 1, annealstop = 1;
FLOAT jitter0 = 0, jitter = 0;
int debuglevel = 0, nruns = 1, irun = 0;
FLOAT wordscale=1;
int VariationalBayes=0;
int tmp;
char filename[100];
{
int chr;
while ((chr = getopt(argc, argv, "a:g:s:p:l:m:n:d:t:b:B:N:j:J:S:d:R:T:VW:")) != -1)
switch (chr) {
case 'a':
rule_bias_default = atof(optarg);
break;
case 'g':
memcpy (filename, optarg, strlen (optarg));
tmp = strlen (optarg);
filename[tmp] = 'N';
tmp++;
filename[tmp] = 'e';
tmp++;
filename[tmp] = 'w';
tmp++;
filename[tmp] = '\0';
tmp++;
grammarfp = fopen(optarg, "r");
if (grammarfp == NULL) {
fprintf(stderr, "Error: couldn't open grammarfile %s\n%s",
optarg, usage);
exit(EXIT_FAILURE);
}
break;
case 's':
stoptol = atof(optarg);
break;
case 'p':
minruleprob = atof(optarg);
break;
case 'l':
maxlen = atoi(optarg);
break;
case 'm':
minits = atoi(optarg);
break;
case 'n':
maxits = atoi(optarg);
break;
case 'b':
annealstart = atof(optarg);
break;
case 'B':
annealstop = atof(optarg);
break;
case 'N':
nanneal = atoi(optarg);
break;
case 'j':
jitter0 = atof(optarg);
break;
case 'J':
jitter = atof(optarg);
break;
case 'S':
randseed = atoi(optarg);
break;
case 'd':
debuglevel = atoi(optarg);
break;
case 'R':
nruns = atoi(optarg);
break;
case 'T':
summaryfp = fopen(optarg, "w");
break;
case 'V':
VariationalBayes = 1;
break;
case 'W':
wordscale = atof(optarg);
break;
case '?':
default:
fprintf(stderr, "Error: unknown command line flag %c\n\n%s\n",
chr, usage);
exit(EXIT_FAILURE);
break;
}
}
if (optind + 1 != argc) {
fprintf(stderr, "Error: expect a yieldfile\n\n%s\n", usage);
exit(EXIT_FAILURE);
}
if ((yieldfp = fopen(argv[optind], "r")) == NULL) {
fprintf(stderr, "Error: Couldn't open yieldfile %s\n%s", argv[optind], usage);
exit(EXIT_FAILURE);
}
srand(randseed);
if (summaryfp && debuglevel >= 100)
fprintf(summaryfp, "# rule_bias_default (-a) = %g, stoptol (-s) = %g, minruleprob (-p) = %g, "
"maxlen (-l) = %d, minits (-m) = %d, maxits = (-n) = %d, annealstart (-b) = %g, "
"annealstop (-B) = %g, nanneal (-N) = %d, jitter0 (-j) = %g, jitter (-J) = %g, "
"VariationalBayes (-V) = %d, wordscale (-W) = %g, randseed (-S) = %d, "
"debuglevel (-d) = %d, nruns (-R) = %d\n",
rule_bias_default, stoptol, minruleprob, maxlen, minits, maxits, annealstart,
annealstop, nanneal, jitter0, jitter, VariationalBayes, wordscale, randseed, debuglevel, nruns);
g0 = read_grammar(grammarfp, si, rule_bias_default);
write_grammar(stdout, g0, si, minruleprob);
set_rule_weights(g0, g0->weights, VariationalBayes); /* normalize rule counts */
signal(SIGINT, write_grammar_);
for (irun = 0; irun < nruns; ++irun) {
FLOAT entropy;
g = copy_grammar(g0, si);
if (summaryfp && debuglevel >= 100)
fprintf(summaryfp, "# Run %d\n", irun);
g_global = g;
si_global = si;
if (jitter0 > 0)
jitter_weights(g, jitter0);
entropy = inside_outside(g, si, yieldfp, tracefp, summaryfp, debuglevel, maxlen,
minits, maxits, stoptol, minruleprob, jitter, VariationalBayes, wordscale,
annealstart, annealstop, nanneal);
if (summaryfp && debuglevel >= 0)
fprintf(summaryfp, "# run %d, entropy %g, %ld rules\n", irun, entropy, (long) g->nrules);
if (debuglevel >= 1) {
write_grammar(stdout, g, si, minruleprob);
FILE* grammarfp = fopen(filename, "w");
//write_grammar(stdout, g, si, minruleprob);
write_grammar(grammarfp, g, si, minruleprob);
fprintf(stdout, "\n");
fflush(stdout);
}
free_grammar(g);
}
free_grammar(g0);
si_free(si);
if (mmm_blocks_allocated)
fprintf(stderr, "Error in mrf(): %ld memory block(s) not deallocated\n",
mmm_blocks_allocated);
/* check that everything has been deallocated */
assert(mmm_blocks_allocated == 0);
exit(EXIT_SUCCESS);
}
int
main(int argc, char **argv)
{
si_t si = make_si(1024);
FILE *grammarfp = stdin, *yieldfp;
FILE *tracefp = NULL; /* trace output */
FILE *summaryfp = stderr; /* end of parse stats output */
FILE *parsefp = stdout; /* parse trees */
FILE *probfp = NULL; /* max_neglog_prob */
chart_cell root_cell;
grammar g;
chart c;
vindex terms;
int maxsentlen = 0;
int sentenceno = 0, parsed_sentences = 0, failed_sentences = 0;
double sum_neglog_prob = 0;
int sentfrom = 0;
int sentto = 0;
srand(RAND_SEED); /* seed random number generator */
if (argc<2 || argc>6) {
fprintf(stderr, "%s yieldfile [maxsentlen [grammarfile [sentfrom sentto]]]\n", argv[0]);
exit(EXIT_FAILURE);
}
if ((yieldfp = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "%s: Couldn't open yieldfile %s\n", argv[0], argv[1]);
exit(EXIT_FAILURE);
}
if (argc >= 3)
if (!sscanf(argv[2], "%d", &maxsentlen)) {
fprintf(stderr, "%s: Couldn't parse maxsentlen %s\n", argv[0], argv[2]);
exit(EXIT_FAILURE);
}
if (argc >= 4)
if ((grammarfp = fopen(argv[3], "r")) == NULL) {
fprintf(stderr, "%s: Couldn't open grammarfile %s\n", argv[0], argv[3]);
exit(EXIT_FAILURE);
}
if (argc >= 6) {
if (!sscanf(argv[4], "%d", &sentfrom)) {
fprintf(stderr, "%s: Couldn't parse sentfrom %s\n", argv[0], argv[4]);
exit(EXIT_FAILURE);
}
if (!sscanf(argv[5], "%d", &sentto)) {
fprintf(stderr, "%s: Couldn't parse sentto %s\n", argv[0], argv[5]);
exit(EXIT_FAILURE);
}
}
g = read_grammar(grammarfp, si);
/* write_grammar(tracefp, g, si); */
while ((terms = read_terms(yieldfp, si))) {
sentenceno++;
if (sentfrom && sentenceno < sentfrom) {
vindex_free(terms);
continue;
}
if (sentto && sentenceno > sentto) {
vindex_free(terms);
break;
}
/* skip if sentence is too long */
if (!maxsentlen || (int) terms->n <= maxsentlen) {
size_t i;
if (tracefp) {
fprintf(tracefp, "\nSentence %d:\n", sentenceno);
for (i=0; i<terms->n; i++)
fprintf(tracefp, " %s", si_index_string(si, terms->e[i]));
fprintf(tracefp, "\n");
}
c = cky(*terms, g, si);
/* fetch best root node */
root_cell = sihashcc_ref(CHART_ENTRY(c, 0, terms->n), g.root_label);
if (root_cell) {
tree parse_tree = bintree_tree(&root_cell->tree, si);
double prob = (double) root_cell->prob;
parsed_sentences++;
assert(prob > 0.0);
sum_neglog_prob -= log(prob);
if (probfp)
fprintf(probfp, "max_neglog_prob(%d, %g).\n",
sentenceno, -log(prob));
if (tracefp)
fprintf(tracefp, " Prob = %g\n", prob);
if (parsefp) {
write_tree(parsefp, parse_tree, si);
fprintf(parsefp, "\n");
/* write_prolog_tree(parsefp, parse_tree, si); */
}
free_tree(parse_tree);
}
else {
failed_sentences++;
if (tracefp)
fprintf(tracefp, "Failed to parse\n");
if (parsefp)
fprintf(parsefp, "parse_failure.\n");
}
chart_free(c, terms->n); /* free the chart */
}
else { /* sentence too long */
if (parsefp)
fprintf(parsefp, "too_long.\n");
}
vindex_free(terms); /* free the terms */
assert(trees_allocated == 0);
assert(bintrees_allocated == 0);
}
free_grammar(g);
si_free(si);
if (summaryfp) {
fprintf(summaryfp, "\n%d/%d = %g%% test sentences met the length criteron,"
" of which %d/%d = %g%% were parsed\n",
parsed_sentences+failed_sentences, sentenceno,
(double) (100.0 * (parsed_sentences+failed_sentences)) /
sentenceno,
parsed_sentences, parsed_sentences+failed_sentences,
(double) (100.0 * parsed_sentences) /
(parsed_sentences + failed_sentences));
fprintf(summaryfp, "Sum(-log prob) = %g\n", sum_neglog_prob);
}
/* check that everything has been deallocated */
/* printf("mmm_blocks_allocated = %ld\n", (long) mmm_blocks_allocated); */
assert(mmm_blocks_allocated == 0);
exit(EXIT_SUCCESS);
}
RakuToken * rakutoken_free(RakuToken * self) {
return si_free(rakutoken_done(self));
}
/* Dispose of workspace */
void wsfree() {
if(_gws.m) free(_gws.m);
if(_gws.s) free(_gws.s);
if(_gws.mi) mi_free(_gws.mi);
if(_gws.si) si_free(_gws.si);
}
