void
unbackspace(char* buf) {
char *readptr, *copyptr, *endptr;
int seen_bs_or_cr;
DPRINTF1(DEBUG_TERMIO,"unbackspace: %s", mangle_string_for_debug_log(buf, MANGLE_LENGTH));
seen_bs_or_cr = FALSE;
for (readptr = copyptr = endptr = buf; *readptr; readptr++) {
assert(endptr <= readptr);
assert(copyptr <= endptr);
switch (*readptr) {
case BACKSPACE:
copyptr = (copyptr > buf ? copyptr - 1 : buf); /* cannot backspace past beginning of buf */
seen_bs_or_cr = TRUE;
break;
case CARRIAGE_RETURN:
copyptr = buf;
seen_bs_or_cr = TRUE;
break;
default:
*copyptr++ = *readptr;
break;
}
if (copyptr > endptr)
endptr = copyptr;
}
*endptr = '\0';
if (seen_bs_or_cr)
DPRINTF1(DEBUG_TERMIO,"unbackspace result: %s", mangle_string_for_debug_log(buf, MANGLE_LENGTH));
}
int32_t
call_function(rmedia_handle_t *handle, void *ip, char *func_name)
{
int32_t ret_val;
int32_t (*fcn_ptr)(rmedia_handle_t *handle, void *ip);
void *lib_handle;
if (handle == NULL) {
DPRINTF("Handle is NULL\n");
errno = EINVAL;
return (-1);
}
lib_handle = handle->sm_lib_handle;
if (handle->sm_signature != LIBSMEDIA_SIGNATURE) {
DPRINTF2("call_function:signature expected=0x%x, found=0x%x\n",
LIBSMEDIA_SIGNATURE, handle->sm_signature);
errno = EINVAL;
return (-1);
}
fcn_ptr = (int32_t (*)(rmedia_handle_t *, void*))
dlsym(lib_handle, func_name);
if (fcn_ptr == NULL) {
DPRINTF1("Could not find %s\n", func_name);
errno = ENOTSUP;
return (-1);
}
ret_val = (*fcn_ptr)(handle, ip);
return (ret_val);
}
void
restore_rl_state()
{
char *newprompt;
move_cursor_to_start_of_prompt(impatient_prompt ? ERASE : DONT_ERASE);
cook_prompt_if_necessary();
newprompt = mark_invisible(saved_rl_state.cooked_prompt); /* bracket (colour) control sequences with \001 and \002 */
rl_expand_prompt(newprompt);
mirror_slaves_echo_mode(); /* don't show passwords etc */
DPRINTF1(DEBUG_READLINE,"newprompt now %s", mangle_string_for_debug_log(newprompt,MANGLE_LENGTH));
rl_callback_handler_install(newprompt, &line_handler);
DPRINTF0(DEBUG_AD_HOC, "freeing newprompt");
free(newprompt); /* readline docs don't say it, but we can free newprompt now (readline apparently
uses its own copy) */
rl_insert_text(saved_rl_state.input_buffer);
rl_point = saved_rl_state.point;
saved_rl_state.already_saved = 0;
DPRINTF0(DEBUG_AD_HOC, "Starting redisplay");
rl_redisplay();
rl_prep_terminal(1);
prompt_is_still_uncooked = FALSE; /* has been done right now */
}
/*
* create pty pair and fork using my_pty_fork; parent returns immediately; child
* executes the part of rlwrap's command line that remains after
* read_options_and_command_name() has harvested rlwrap's own options
*/
static void
fork_child(char *command_name, char **argv)
{
char *arg = argv[optind], *p, **argp;
int pid;
command_line = mysavestring(arg);
for (argp = argv + optind + 1; *argp; argp++) {
command_line = append_and_free_old (command_line, " ");
command_line = append_and_free_old (command_line, *argp);
}
pid = my_pty_fork(&master_pty_fd, &saved_terminal_settings, &winsize);
if (pid > 0) /* parent: */
return;
else { /* child: */
DPRINTF1(DEBUG_TERMIO, "preparing to execute %s", arg);
close_open_files_without_writing_buffers();
if (client_term_name)
mysetenv("TERM", client_term_name);
if (execvp(argv[optind], &argv[optind]) < 0) {
if (last_opt > 0 && last_option_didnt_have_optional_argument) { /* e.g. 'rlwrap -a Password: sqlpus' will try to exec 'Password:'******'; !(){}"; *p; p++) /* does arg need shell quoting? */
if (strchr(arg,*p)) {
arg = add3strings("'", arg,"'"); /* quote it */
break;
}
fprintf(stderr, "Did you mean '%s' to be an option argument?\nThen you should write -%c%s, without the space(s)\n",
argv[optind], last_opt, arg);
}
myerror("Cannot execute %s", argv[optind]); /* stillborn child, parent will live on and display child's last gasps */
}
}
}
int
prompt_is_single_line(void)
{
int homegrown_redisplay= FALSE;
int force_homegrown_redisplay = FALSE;
int retval;
#ifndef SPY_ON_READLINE
# define _rl_horizontal_scroll_mode FALSE
# define rl_variable_value(s) "off"
#else
# ifndef HAVE_RL_VARIABLE_VALUE
# define rl_variable_value(s) "off"
# endif
#endif
#ifdef HOMEGROWN_REDISPLAY
homegrown_redisplay=TRUE;
#endif
#ifdef DEBUG
force_homegrown_redisplay = debug & FORCE_HOMEGROWN_REDISPLAY;
#endif
retval = _rl_horizontal_scroll_mode ||
strncmp(rl_variable_value("horizontal-scroll-mode"),"on",3) == 0 ||
homegrown_redisplay ||
force_homegrown_redisplay;
DPRINTF1(DEBUG_READLINE, "prompt is %s-line", (retval ? "single" : "multi"));
return retval;
}
/* returns a colourised copy of prompt, trailing space is not colourised */
char*
colourise (const char *prompt)
{
char *prompt_copy, *trailing_space, *colour_end_with_space, *result, *p;
prompt_copy = mysavestring(prompt);
if (strchr(prompt_copy, '\033') || strchr(prompt_copy, RL_PROMPT_START_IGNORE) ) { /* prompt contains escape codes? */
DPRINTF1(DEBUG_READLINE, "colourise %s: left as-is", prompt);
return prompt_copy; /* if so, leave prompt alone */
}
for (p = prompt_copy + strlen(prompt_copy); p > prompt_copy && *(p-1) == ' '; p--)
; /* skip back over trailing space */
trailing_space = mysavestring(p); /* p now points at first trailing space, or else the final NULL */
*p = '\0';
colour_end_with_space = add2strings(colour_end, trailing_space);
result = add3strings(colour_start, prompt_copy, colour_end_with_space);
free (prompt_copy); free(trailing_space); free(colour_end_with_space);
DPRINTF1(DEBUG_READLINE, "colourise %s: colour added ", prompt);
return result;
}
static int
direct_keypress(int UNUSED(count), int key)
{
char *key_as_str = mysavestring("?");
/* put the key in the output queue */
*key_as_str = key;
DPRINTF1(DEBUG_READLINE,"direct keypress: %s", mangle_char_for_debug_log(key, TRUE));
put_in_output_queue(key_as_str);
free(key_as_str);
return 0;
}
void
init_readline(char *UNUSED(prompt))
{
DPRINTF1(DEBUG_READLINE, "Initialising readline version %x", rl_readline_version);
rl_add_defun("rlwrap-accept-line", my_accept_line,-1);
rl_add_defun("rlwrap-accept-line-and-forget", my_accept_line_and_forget,-1);
rl_add_defun("rlwrap-call-editor", munge_line_in_editor, -1);
rl_add_defun("rlwrap-direct-keypress", direct_keypress, -1);
rl_add_defun("rlwrap-hotkey", handle_hotkey, -1);
rl_add_defun("rlwrap-hotkey-ignore-history", handle_hotkey_ignore_history, -1);
/* only useful while debugging */
rl_add_defun("rlwrap-dump-all-keybindings", dump_all_keybindings,-1);
rl_add_defun("rlwrap-debug-ad-hoc", debug_ad_hoc, -1);
/* the old rlwrap bindable function names with underscores are deprecated: */
rl_add_defun("rlwrap_accept_line_and_forget", please_update_alaf,-1);
rl_add_defun("rlwrap_call_editor", please_update_ce,-1);
rl_variable_bind("blink-matching-paren","on"); /* Shouldn't this be on by default? */
bindkey('\n', my_accept_line, "emacs-standard; vi-insert; vi-command");
bindkey('\r', my_accept_line, "emacs-standard; vi-insert; vi-command");
bindkey(15, my_accept_line_and_forget, "emacs-standard; vi-insert; vi-command"); /* ascii #15 (Control-O) is unused in readline's emacs and vi keymaps */
if (multiline_separator)
bindkey(30, munge_line_in_editor, "emacs-standard;vi-insert;vi-command"); /* CTRL-^: unused in vi-insert-mode, hardly used in emacs (doubles arrow-up) */
/* rl_variable_bind("gnah","gnerp"); It is not possible to create new readline variables (only functions) */
rl_catch_signals = 0;
rl_initialize(); /* This has to happen *before* we set rl_redisplay_function, otherwise
readline will not bother to call tgetent(), will be agnostic about terminal
capabilities and hence not be able to honour e.g. a set horizontal-scroll-mode off
in .inputrc */
using_history();
rl_redisplay_function = my_redisplay;
rl_completion_entry_function =
(rl_compentry_func_t *) & my_completion_function;
rl_catch_signals = FALSE;
rl_catch_sigwinch = FALSE;
saved_rl_state.input_buffer = mysavestring(pre_given ? pre_given : ""); /* Even though the pre-given input won't be displayed before the first
cooking takes place, we still want it to be accepted when the user
presses ENTER before that (e.g. because she already knows the
pre-given input and wants to accept that) */
saved_rl_state.point = strlen(saved_rl_state.input_buffer);
saved_rl_state.raw_prompt = mysavestring("");
saved_rl_state.cooked_prompt = NULL;
}
void
write_EOF_to_master_pty()
{
struct termios *pterm_slave = my_tcgetattr(slave_pty_fd, "slave pty");
char *sent_EOF = mysavestring("?");
*sent_EOF = (pterm_slave && pterm_slave->c_cc[VEOF] ? pterm_slave->c_cc[VEOF] : 4) ; /*@@@ HL shouldn't we directly mysavestring(pterm_slave->c_cc[VEOF]) ??*/
DPRINTF1(DEBUG_TERMIO, "Sending %s", mangle_string_for_debug_log(sent_EOF, MANGLE_LENGTH));
put_in_output_queue(sent_EOF);
myfree(pterm_slave);
free(sent_EOF);
}
int
adapt_tty_winsize(int from_fd, int to_fd)
{
int ret;
struct winsize old_winsize = winsize;
ret = ioctl(from_fd, TIOCGWINSZ, &winsize);
DPRINTF1(DEBUG_SIGNALS, "ioctl (..., TIOCGWINSZ) = %d", ret);
if (winsize.ws_col != old_winsize.ws_col || winsize.ws_row != old_winsize.ws_row) {
DPRINTF4(DEBUG_SIGNALS, "ws.col: %d -> %d, ws.row: %d -> %d", old_winsize.ws_col, winsize.ws_col, old_winsize.ws_row, winsize.ws_row);
if (always_readline &&!dont_wrap_command_waits()) /* if --always_readline option is set, the client will probably spew a */
deferred_adapt_commands_window_size = TRUE; /* volley of control chars at us when its terminal is resized. Hence we don't do it now */
else {
ret = ioctl(to_fd, TIOCSWINSZ, &winsize);
DPRINTF1(DEBUG_SIGNALS, "ioctl (..., TIOCSWINSZ) = %d", ret);
}
DPRINTF2(DEBUG_READLINE, "rl_prompt: %s, line_buffer: %s", mangle_string_for_debug_log(rl_prompt, 100), rl_line_buffer);
rl_set_screen_size(winsize.ws_row, winsize.ws_col); /* this is safe: we know that right now rlwrap is not calling
the readline library because we keep SIGWINCH blocked all the time */
if (!within_line_edit && !skip_rlwrap()) {
wipe_textarea(&old_winsize);
received_WINCH = TRUE; /* we can't start line edit in signal handler, so we only set a flag */
} else if (within_line_edit) { /* try to keep displayed line tidy */
wipe_textarea(&old_winsize);
rl_on_new_line();
rl_redisplay();
}
return (!always_readline || dont_wrap_command_waits()); /* pass the signal on (except when always_readline is set and command is not waiting) */
} else { /* window size has not changed */
return FALSE;
}
}
void myalarm(int msecs) {
#ifdef HAVE_SETITIMER
struct itimerval awhile = {{0,0},{0,0}};
awhile.it_value.tv_usec = msecs * 1000;
received_sigALRM = FALSE;
setitimer(ITIMER_REAL, &awhile, NULL);
#else
received_sigALRM = FALSE;
alarm(msecs == 0 ? 0 : 1 + msecs/1000));
#endif
DPRINTF1(DEBUG_AD_HOC, "set alarm (%d msecs)", msecs);
if (msecs == 0)
return;
myalarm_was_set = TRUE;
}
/* display (or remove, if message == NULL) message in echo area, with the appropriate bookkeeping */
void
message_in_echo_area(char *message)
{
static int message_in_echo_area = FALSE;
DPRINTF1(DEBUG_READLINE, "message: %s", mangle_string_for_debug_log(message, MANGLE_LENGTH));
if (message) {
rl_save_prompt();
message_in_echo_area = TRUE;
rl_message(message);
} else {
if (message_in_echo_area)
rl_restore_prompt();
rl_clear_message();
message_in_echo_area = FALSE;
}
}
static char* entire_history_as_one_string(void) {
HIST_ENTRY **the_list = history_list(), **entryp;
if (!the_list) /* i.e. if there is no history */
return mysavestring("");
char *big_string = mymalloc(history_total_bytes() + history_length + 1);
char * stringp = big_string;
for (entryp = the_list; *entryp; entryp++) {
int length = strlen((*entryp)->line);
strncpy(stringp, (*entryp)->line, length); /* copy line, without closing NULL byte; */
stringp +=length;
*stringp++ = '\n';
}
*stringp = '\0';
DPRINTF1(DEBUG_READLINE, "stringified %d bytes of history", (int) strlen(big_string));
return big_string;
}
char *
search_and_replace(char *patt, char *repl, const char *string, int cursorpos,
int *line, int *col)
{
int i, j, k;
int pattlen = strlen(patt);
int replen = strlen(repl);
int stringlen = strlen(string);
int cursor_found = FALSE;
int current_line = 1;
int current_column = 0;
size_t scratchsize;
char *scratchpad, *result;
assert(patt && repl && string);
DPRINTF2(DEBUG_READLINE, "string=%s, cursorpos=%d",
mangle_string_for_debug_log(string, 40), cursorpos);
scratchsize = max(stringlen, (stringlen * replen) / pattlen) + 1; /* worst case : repleng > pattlen and string consists of only <patt> */
DPRINTF1(DEBUG_READLINE, "Allocating %d bytes for scratchpad", (int) scratchsize);
scratchpad = mymalloc(scratchsize);
for (i = j = 0; i < stringlen; ) {
if (line && col && /* if col and line are BOTH non-NULL, and .. */
i >= cursorpos && !cursor_found) { /* ... for the first time, i >= cursorpos: */
cursor_found = TRUE; /* flag that we're done here */
*line = current_line; /* update *line */
*col = current_column; /* update *column */
}
if (strncmp(patt, string + i, pattlen) == 0) { /* found match */
i += pattlen; /* update i ("jump over" patt (and, maybe, cursorpos)) */
for (k = 0; k < replen; k++) /* append repl to scratchpad */
scratchpad[j++] = repl[k];
current_line++; /* update line # (assuming that repl = "\n") */
current_column = 0; /* reset column */
} else {
scratchpad[j++] = string[i++]; /* or else just copy things */
current_column++;
}
}
if (line && col)
DPRINTF2(DEBUG_READLINE, "line=%d, col=%d", *line, *col);
scratchpad[j] = '\0';
result = mysavestring(scratchpad);
free(scratchpad);
return (result);
}
void
initialise_colour_codes(char *colour)
{
int attributes, foreground, background;
DPRINTF1(DEBUG_READLINE, "initialise_colour_codes(\"%s\")", colour);
attributes = foreground = -1;
background = 40; /* don't need to specify background; 40 passes the test automatically */
sscanf(colour, "%d;%d;%d", &attributes, &foreground, &background);
#define OUTSIDE(lo,hi,val) (val < lo || val > hi)
if (OUTSIDE(0,8,attributes) || OUTSIDE(30,37,foreground) || OUTSIDE(40,47,background))
myerror(FATAL|NOERRNO, "\n"
" prompt colour spec should be <attr>;<fg>[;<bg>]\n"
" where <attr> ranges over [0...8], <fg> over [30...37] and <bg> over [40...47]\n"
" example: 0;33 for yellow on current background, 1;31;40 for bold red on black ");
colour_start= add3strings("\033[", colour,"m");
colour_end = "\033[0m";
}
void recoverFromCache() {
int i;
char *readedUntil;
assert(s_cache.cpi >= 1);
s_cache.activeCache = 0;
/* s_cache.recoveringFromCache = 1;*/
DPRINTF1(": reading from cache\n");
readedUntil = s_cache.cp[0].lbcc;
for(i=1; i<s_cache.cpi; i++) {
/*fprintf(dumpOut,"try to recover cache point %d\n",i);fflush(dumpOut);*/
if (cachedInputPass(i,&readedUntil) == 0) break;
if (cachedIncludedFilePass(i) == 0) break;
}
assert(i > 1);
/* now, recover state from the cache point 'i-1' */
DPRINTF2("recovering cache point %d\n",i-1);
recoverCachePoint(i-1, readedUntil, 1);
}
void
init_readline(char *prompt)
{
DPRINTF1(DEBUG_READLINE, "Initialising readline version %x", rl_readline_version);
rl_add_defun("rlwrap-accept-line", my_accept_line,-1);
rl_add_defun("rlwrap-accept-line-and-forget", my_accept_line_and_forget,-1);
rl_add_defun("rlwrap-dump-all-keybindings", dump_all_keybindings,-1);
rl_add_defun("rlwrap-call-editor", munge_line_in_editor, -1);
/* rlwrap bindable function names with underscores are deprecated: */
rl_add_defun("rlwrap_accept_line_and_forget", please_update_alaf,-1);
rl_add_defun("rlwrap_call_editor", please_update_ce,-1);
rl_variable_bind("blink-matching-paren","on"); /* Shouldn't this be on by default? */
bindkey('\n', my_accept_line, "emacs-standard; vi-insert; vi-command");
bindkey('\r', my_accept_line, "emacs-standard; vi-insert; vi-command");
bindkey(15, my_accept_line_and_forget, "emacs-standard; vi-insert; vi-command"); /* ascii #15 (Control-O) is unused in readline's emacs and vi keymaps */
if (multiline_separator)
bindkey(30, munge_line_in_editor, "emacs-standard;vi-insert;vi-command"); /* CTRL-^: unused in vi-insert-mode, hardly used in emacs (doubles arrow-up) */
if (debug)
bindkey(7, dump_all_keybindings,"emacs-standard; vi-insert; vi-move; vi-command" /* "emacs-ctlx; emacs-meta" */); /* CTRL-G */
/* rl_variable_bind("gnah","gnerp"); It is not possible to create new readline variables (only functions) */
rl_catch_signals = 0;
rl_initialize(); /* This has to happen *before* we set rl_redisplay_function, otherwise
readline will not bother to call tgetent(), will be agnostic about terminal
capabilities and hence not be able to honour e.g. a set horizontal-scroll-mode off
in .inputrc */
using_history();
rl_redisplay_function = my_redisplay;
rl_completion_entry_function =
(rl_compentry_func_t *) & my_completion_function;
rl_catch_signals = FALSE;
rl_catch_sigwinch = FALSE;
saved_rl_state.input_buffer = mysavestring("");
saved_rl_state.raw_prompt = mysavestring("");
saved_rl_state.cooked_prompt = NULL;
}
void suicide_by(int signal, int status) {
/* Some signals suggest a program error. When rlwrap kills itself with one of those,
the shell may tell the user that rlwrap itself has failed. Make clear that
it didn't. @@@ We could also try argv[0] = command_name just before dying ? */
if (signals_program_error(signal)) {
myerror(WARNING|NOERRNO, "%s crashed, killed by %s%s.\n%s itself has not crashed, but for transparency,\n"
"it will now kill itself %swith the same signal\n",
command_name, signal_name(signal), (coredump(status) ? " (core dumped)" : ""),
program_name, (coredump(status) ? "" : "(without dumping core) ") );
}
uninstall_signal_handlers();
unblock_all_signals();
set_ulimit(RLIMIT_CORE,0); /* prevent our own useless core dump from clobbering the interesting one created by command */
DPRINTF1(DEBUG_SIGNALS, "suicide by signal %s", signal_name(signal));
kill(getpid(), signal);
/* still alive? */
sleep(1);
exit(0);
}
/*
* value_to_name - translate an address into a string + offset
*
* mod_lock locking is not needed fro the modules list because
* modctl structures are never unlinked from the &modules list.
*/
ulong_t
value_to_name(uintptr_t value, char *symbol)
{
struct modctl *modp = &modules;
ulong_t offset;
char *name;
DPRINTF1("value_to_name: Looking for %p\n", (void *)value);
do {
if (modp->mod_mp &&
(name = kobj_searchsym(modp->mod_mp, value, &offset))) {
(void) strcpy(symbol, modp->mod_modname);
(void) strcat(symbol, ":");
(void) strcat(symbol, name);
return (offset);
}
} while ((modp = modp->mod_next) != &modules);
*symbol = (char)0;
return ((ulong_t)-1l);
}
static void
munge_file_in_editor(const char *filename, int lineno, int colno)
{
int ret;
char *editor_command1, *editor_command2, *editor_command3,
*editor_command4, *line_number_as_string, *column_number_as_string, **possible_editor_commands;
/* find out which editor command we have to use */
possible_editor_commands = list4(getenv("RLWRAP_EDITOR"), getenv("EDITOR"), getenv("VISUAL"), "vi +%L");
editor_command1 = first_of(possible_editor_commands);
line_number_as_string = as_string(lineno);
column_number_as_string = as_string(colno);
editor_command2 = search_and_replace("%L", line_number_as_string, editor_command1, 0, NULL, NULL);
editor_command3 = search_and_replace("%C", column_number_as_string, editor_command2, 0, NULL, NULL);
editor_command4 = strstr(editor_command3, "%F") ?
search_and_replace("%F", filename, editor_command3, 0, NULL, NULL) :
add3strings(editor_command3, " ", filename);
/* call editor, temporarily restoring terminal settings */
if (terminal_settings_saved && (tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved_terminal_settings) < 0)) /* reset terminal */
myerror(FATAL|USE_ERRNO, "tcsetattr error on stdin");
DPRINTF1(DEBUG_READLINE, "calling %s", editor_command4);
if ((ret = system(editor_command4))) {
if (WIFSIGNALED(ret)) {
fprintf(stderr, "\n");
myerror(FATAL|NOERRNO, "editor killed by signal");
} else {
myerror(FATAL|USE_ERRNO, "failed to invoke editor with '%s'", editor_command4);
}
}
completely_mirror_slaves_terminal_settings();
ignore_queued_input = TRUE;
free_multiple(possible_editor_commands, editor_command2, editor_command3,
editor_command4, line_number_as_string, column_number_as_string, FMEND);
}
/* returns TRUE if the -N option has been specified, we can read /proc/<command_pid>/wchan,
(which happens only on linux, as far as I know) and what we read there contains the word "wait"
meaning (presumably...) that command is waiting for one of its children
if otherwise returns FALSE
*/
int dont_wrap_command_waits() {
static char command_wchan[MAXPATHLEN+1];
static int initialised = FALSE;
static int wchan_fd;
static int been_warned = 0;
char buffer[BUFFSIZE];
int nread, result = FALSE;
DEBUG_RANDOM_SLEEP;
if (!commands_children_not_wrapped)
return FALSE;
if (!initialised) { /* first time we're called after birth of child */
snprintf2(command_wchan, MAXPATHLEN , "%s/%d/wchan", PROC_MOUNTPOINT, command_pid);
initialised = TRUE;
}
if (command_is_dead)
return TRUE; /* This is lazy!! signal may not have been delivered @@@ */
wchan_fd = open(command_wchan, O_RDONLY);
if (wchan_fd < 0) {
if (been_warned++ == 0) {
mywarn("you probably specified the -N (-no-children) option"
" - but spying\non %s's wait status does not work on"
" your system, as we cannot read %s", command_name, command_wchan);
}
return FALSE;
}
if (((nread = read(wchan_fd, buffer, BUFFSIZE -1)) > 0)) {
buffer[nread] = '\0';
DPRINTF1(DEBUG_READLINE, "read commands wchan: <%s> ", buffer);
result = (strstr(buffer, "wait") != NULL);
}
close(wchan_fd);
DEBUG_RANDOM_SLEEP;
return result;
}
static void *
get_dev_library_handle(int32_t fd)
{
void *handle;
void *old_handle = NULL;
struct dk_cinfo dkinfo;
DIR *dirp;
struct dirent *dp;
char *pathname;
int32_t (*d_fcn_ptr)(ushort_t, ushort_t);
int32_t (*v_fcn_ptr)(void);
int32_t ret_val;
if (ioctl(fd, DKIOCINFO, &dkinfo) == -1) {
PERROR("DKIOCINFO failed");
return (NULL);
}
DPRINTF1("dki_ctype = 0x%x\n", dkinfo.dki_ctype);
if ((pathname = malloc(PATH_MAX)) == NULL) {
PERROR("malloc failed");
return (NULL);
}
dirp = opendir(PATHNAME);
if (dirp == NULL) {
(void) fprintf(stderr, gettext("Couldnot open %s\n"), PATHNAME);
free(pathname);
return (NULL);
}
while ((dp = readdir(dirp)) != NULL) {
if (strncmp("sm_", dp->d_name, 3) != 0) {
DPRINTF1("not a library %s\n", dp->d_name);
continue;
}
if (snprintf(pathname, PATH_MAX, "%s/%s",
PATHNAME, dp->d_name) >= PATH_MAX) {
continue;
}
handle = dlopen(pathname, RTLD_LAZY);
if (handle == NULL) {
PERROR("Error opening library file");
continue;
}
d_fcn_ptr = (int32_t (*)(ushort_t, ushort_t))dlsym(handle,
"_m_device_type");
if (d_fcn_ptr == NULL) {
DPRINTF("Could not find _m_device_type\n");
(void) dlclose(handle);
continue;
}
ret_val = (*d_fcn_ptr)(dkinfo.dki_ctype, 0);
if (ret_val == 0) {
DPRINTF1("NAME %s\n", dp->d_name);
v_fcn_ptr = (int32_t (*)(void))dlsym(handle,
"_m_version_no");
if (v_fcn_ptr == NULL) {
DPRINTF("Could not find _m_version_no\n");
(void) dlclose(handle);
continue;
}
ret_val = (*v_fcn_ptr)();
if ((ret_val >= 0) &&
(ret_val >= SM_PLUGIN_VERSION)) {
if (old_handle != NULL)
(void) dlclose(old_handle);
old_handle = handle;
continue;
} else {
(void) dlclose(handle);
}
} else {
(void) dlclose(handle);
}
}
free(pathname);
(void) closedir(dirp);
return (old_handle);
}
static int32_t
format_floppy(int32_t fd, void *ip)
{
struct format_track *ft = (struct format_track *)ip;
int32_t format_flags;
int32_t transfer_rate = 1000; /* transfer rate code */
int32_t sec_size = 512; /* sector size */
uchar_t gap = 0x54; /* format gap size */
uchar_t *fbuf, *p;
int32_t cyl_size;
int32_t i;
int32_t chgd; /* for testing disk changed/present */
int32_t cyl, hd;
int32_t size_of_part, size_of_dev;
int32_t spt = 36; /* sectors per track */
int32_t drive_size;
uchar_t num_cyl = 80; /* max number of cylinders */
struct fd_char save_fdchar; /* original diskette characteristics */
struct dk_allmap save_allmap; /* original diskette partition info */
int32_t D_flag = 0; /* double (aka low) density flag */
int32_t E_flag = 0; /* extended density */
int32_t H_flag = 0; /* high density */
int32_t M_flag = 0; /* medium density */
struct fd_char fdchar;
struct dk_geom fdgeom;
struct dk_allmap allmap;
struct dk_cinfo dkinfo;
int32_t start_head, end_head, start_cyl, end_cyl;
/* for verify buffers */
static uchar_t *obuf;
/* FDRAW ioctl command structures for seeking and formatting */
struct fd_raw fdr_seek = {
FDRAW_SEEK, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0
};
struct fd_raw fdr_form = {
0x4D, 0, 2, 0, 0x54, (char)0xA5, 0, 0, 0, 0,
6,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, /* nbytes */
0 /* addr */
};
format_flags = ft->flag;
DPRINTF1("Format flag is %d\n", format_flags);
if (format_flags == SM_FORMAT_HD) {
H_flag = 1;
} else if (format_flags == SM_FORMAT_DD) {
D_flag = 1;
} else if (format_flags == SM_FORMAT_ED) {
E_flag = 1;
} else if (format_flags == SM_FORMAT_MD) {
M_flag = 1;
} else {
DPRINTF("Invalid operation \n");
errno = ENOTSUP;
return (-1);
}
/*
* restore drive to default geometry and characteristics
* (probably not implemented on sparc)
*/
(void) ioctl(fd, FDDEFGEOCHAR, NULL);
if (ioctl(fd, DKIOCINFO, &dkinfo) < 0) {
PERROR("DKIOCINFO failed.");
exit(3);
}
/* get the default partititon maps */
if (ioctl(fd, DKIOCGAPART, &allmap) < 0) {
PERROR("DKIOCGAPART failed.");
return (-1);
}
/* Save the original default partition maps */
save_allmap = allmap;
/* find out the characteristics of the default diskette */
if (ioctl(fd, FDIOGCHAR, &fdchar) < 0) {
PERROR("FDIOGCHAR failed.");
return (-1);
}
/* Save the original characteristics of the default diskette */
save_fdchar = fdchar;
/*
* The user may only format the entire diskette.
* formatting partion a or b is not allowed
*/
size_of_part = allmap.dka_map[dkinfo.dki_partition].dkl_nblk
* DEV_BSIZE;
size_of_dev = fdchar.fdc_ncyl * fdchar.fdc_nhead
* fdchar.fdc_secptrack * fdchar.fdc_sec_size;
if (size_of_part != size_of_dev) {
DPRINTF("The entire diskette must be formatted\n");
DPRINTF1("size_of_part %d\n", size_of_part);
DPRINTF1("size_of_dev %d\n", size_of_dev);
errno = ENOTSUP;
return (-1);
}
/* find out the geometry of the drive */
if (ioctl(fd, DKIOCGGEOM, &fdgeom) < 0) {
PERROR("DKIOCGGEOM failed.");
return (-1);
}
#ifdef sparc
fdchar.fdc_medium = 3;
#endif
if (fdchar.fdc_medium == 5)
drive_size = 5;
else
drive_size = 3;
/*
* set proper density flag in case we're formating to default
* characteristics because no density switch was input
*/
/* XXX */
if ((E_flag | H_flag | D_flag | M_flag) == 0) {
switch (fdchar.fdc_transfer_rate) {
case 1000:
/* assumes only ED uses 1.0 MB/sec */
E_flag++;
break;
case 500:
default:
/*
* default to HD even though High density and
* "medium" density both use 500 KB/sec
*/
H_flag++;
break;
#ifndef sparc
case 250:
/* assumes only DD uses 250 KB/sec */
D_flag++;
break;
#endif
}
}
if (H_flag) {
transfer_rate = 500;
num_cyl = 80;
sec_size = 512;
if (drive_size == 5) {
spt = 15;
} else {
spt = 18;
}
gap = 0x54;
} else if (D_flag) {
transfer_rate = 250;
if (drive_size == 5) {
if (fdchar.fdc_transfer_rate == 500) {
/*
* formatting a 360KB DD diskette in
* a 1.2MB drive is not a good idea
*/
transfer_rate = 300;
fdchar.fdc_steps = 2;
}
num_cyl = 40;
gap = 0x50;
} else {
num_cyl = 80;
gap = 0x54;
}
sec_size = 512;
spt = 9;
} else if (M_flag) {
#ifdef sparc
transfer_rate = 500;
#else
/*
* 416.67 KB/sec is the effective transfer rate of a "medium"
* density diskette spun at 300 rpm instead of 360 rpm
*/
transfer_rate = 417;
#endif
num_cyl = 77;
sec_size = 1024;
spt = 8;
gap = 0x74;
} else if (E_flag) {
transfer_rate = 1000;
num_cyl = 80;
sec_size = 512;
spt = 36;
gap = 0x54;
}
/*
* Medium density diskettes have 1024 byte blocks. The dk_map
* structure in dklabel.h assumes the blocks size is DEVBSIZE (512)
* bytes. The dkl_nblk field is in terms of DEVBSIZE byte blocks
* while the spt variable is in terms of the true block size on
* the diskette.
*/
if (allmap.dka_map[2].dkl_nblk !=
(2 * num_cyl * spt * (M_flag ? 2 : 1))) {
allmap.dka_map[1].dkl_cylno = num_cyl - 1;
allmap.dka_map[0].dkl_nblk = 2 * (num_cyl - 1) * spt *
(M_flag ? 2 : 1);
allmap.dka_map[1].dkl_nblk = 2 * spt * (M_flag ? 2 : 1);
allmap.dka_map[2].dkl_nblk = 2 * num_cyl * spt *
(M_flag ? 2 : 1);
if (allmap.dka_map[3].dkl_nblk)
allmap.dka_map[3].dkl_nblk = 2 * (num_cyl - 1) * spt *
(M_flag ? 2 : 1);
if (allmap.dka_map[4].dkl_nblk)
allmap.dka_map[4].dkl_nblk =
2 * spt * (M_flag ? 2 : 1);
}
#ifndef sparc
if (num_cyl > fdchar.fdc_ncyl || spt > fdchar.fdc_secptrack ||
transfer_rate > fdchar.fdc_transfer_rate) {
PERROR("drive not capable of requested density");
return (-1);
}
#endif
if (num_cyl != fdchar.fdc_ncyl || spt != fdchar.fdc_secptrack ||
transfer_rate != fdchar.fdc_transfer_rate) {
/*
* -- CAUTION --
* The SPARC fd driver is using a non-zero value in
* fdc_medium to indicate the 360 rpm, 77 track,
* 9 sectors/track, 1024 bytes/sector mode of operation
* (similar to an 8", DS/DD, 1.2 MB floppy).
*
* The x86 fd driver uses fdc_medium as the diameter
* indicator, either 3 or 5. It should not be modified.
*/
#ifdef sparc
fdchar.fdc_medium = M_flag ? 1 : 0;
#endif
fdchar.fdc_transfer_rate = transfer_rate;
fdchar.fdc_ncyl = num_cyl;
fdchar.fdc_sec_size = sec_size;
fdchar.fdc_secptrack = spt;
if (ioctl(fd, FDIOSCHAR, &fdchar) < 0) {
PERROR("FDIOSCHAR (density selection) failed");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
if (ioctl(fd, DKIOCSAPART, &allmap) < 0) {
PERROR("DKIOCSAPART failed");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
}
cyl_size = 2 * sec_size * spt;
if ((obuf = (uchar_t *)malloc((size_t)cyl_size)) == 0) {
PERROR("car't malloc verify buffer");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
/*
* for those systems that support this ioctl, they will
* return whether or not a diskette is in the drive.
*/
if (ioctl(fd, FDGETCHANGE, &chgd) == 0) {
if (chgd & FDGC_CURRENT) {
(void) fprintf(stderr,
gettext("no diskette in drive \n"));
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
if (chgd & FDGC_CURWPROT) {
(void) fprintf(stderr,
gettext("Media is write protected\n"));
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
}
if ((fbuf = (uchar_t *)malloc((unsigned)(4 * spt))) == 0) {
PERROR("Could not malloc format header buffer");
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
/*
* do the format, a track at a time
*/
if (ft->track_no == -1) {
start_cyl = 0;
end_cyl = num_cyl;
start_head = 0;
end_head = fdchar.fdc_nhead;
} else {
start_cyl = ft->track_no;
end_cyl = ft->track_no + 1;
start_head = ft->head;
end_head = ft->head + 1;
if ((end_cyl > num_cyl) || (end_head > fdchar.fdc_nhead)) {
errno = EINVAL;
return (-1);
}
}
for (cyl = start_cyl; cyl < (int32_t)end_cyl; cyl++) {
/*
* This is not the optimal ioctl to format the floppy.
* The device driver should do do the work,
* instead of this program mucking with a lot
* of low-level, device-dependent code.
*/
fdr_seek.fdr_cmd[2] = cyl;
if (ioctl(fd, FDRAW, &fdr_seek) < 0) {
(void) fprintf(stderr,
gettext(" seek to cyl %d failed\n"),
cyl);
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
/*
* Assume that the fd driver has issued a SENSE_INT
* command to complete the seek operation.
*/
for (hd = start_head; hd < end_head; hd++) {
p = (uchar_t *)fbuf;
for (i = 1; i <= spt; i++) {
*p++ = (uchar_t)cyl;
*p++ = (uchar_t)hd;
*p++ = (uchar_t)i; /* sector # */
*p++ = (sec_size == 1024) ? 3 : 2;
}
/*
* ASSUME the fd driver is going to set drive-select
* bits in the second command byte
*/
fdr_form.fdr_cmd[1] = hd << 2;
fdr_form.fdr_cmd[2] = (sec_size == 1024) ? 3 : 2;
fdr_form.fdr_cmd[3] = spt;
fdr_form.fdr_cmd[4] = gap;
fdr_form.fdr_nbytes = 4 * spt;
fdr_form.fdr_addr = (char *)fbuf;
if (ioctl(fd, FDRAW, &fdr_form) < 0) {
(void) fprintf(stderr,
gettext(
"format of cyl %d head %d failed\n"),
cyl, hd);
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
if (fdr_form.fdr_result[0] & 0xC0) {
if (fdr_form.fdr_result[1] & 0x02) {
(void) fprintf(stderr, gettext(
/*CSTYLED*/
"diskette is write protected\n"));
/*
* restore the default
* characteristics
*/
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
(void) fprintf(stderr,
gettext(
"format of cyl %d head %d failed\n"),
cyl, hd);
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
}
/*
* do a quick verify
*/
if (llseek(fd, cyl * cyl_size, 0) != cyl * cyl_size) {
PERROR(" bad seek to format verify, ");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
if (fdchar.fdc_nhead == end_head) {
if (read(fd, obuf, cyl_size) != cyl_size) {
PERROR("Could not read format data");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar,
save_allmap);
return (-1);
}
}
}
if (llseek(fd, (off_t)0, 0) != 0) {
PERROR("seek to blk 0 failed");
/* restore the default characteristics */
restore_default_chars(fd, save_fdchar, save_allmap);
return (-1);
}
return (0);
}
/*
The main entry to LSH package. Depending on the command line
parameters, the function computes the R-NN data structure optimal
parameters and/or construct the R-NN data structure and runs the
queries on the data structure.
*/
int main_T(int nargs, char **args)
{
//先分析参数
/* 官方lsh文件：10个参数
1000 9 784 0.9 0.6 mnist1k.dts mnist1k.q
bin/LSHMain $nDataSet $nQuerySet $dimension $successProbability "$1" "$2" "$3" $m -c*/
//算参数 bin/LSHMain 1000 9 784 0.9 "0.6" "mnist1k.dts" "mnist1k.q" 1002000000 -c
//bin/LSHMain $nDataSet $nQuerySet $dimension $successProbability 1.0 "$1" "$2" $m -p "$3"
//匹配 bin/LSHMain 1000 9 784 0.9 1.0 "mnist1k.dts" "mnist1k.q" 1002000000 -p "outputparma.txt"
if(nargs < 9)
{
usage(args[0]);
exit(1);
}
//initializeLSHGlobal();
// Parse part of the command-line parameters.
nPoints = atoi(args[1]);
IntT nQueries = atoi(args[2]);
pointsDimension = atoi(args[3]);
successProbability = atof(args[4]);
char* endPtr[1];
RealT thresholdR = strtod(args[5], endPtr);//点相邻的距离阈值
//str-to -double 将字符串转换成浮点数的函数
//endPtr 接收数字结尾后非字符串字母
//这个r阈值是什么呢？
if (thresholdR == 0 || endPtr[1] == args[5])
{//如果阈值为0，或者第一个字符就不是数字，
//表示是用文件保存的
//这大概是用于测试哪个阈值好的
// The value for R is not specified, instead there is a file
// specifying multiple R's.
thresholdR = 0;
// Read in the file
FILE *radiiFile = fopen(args[5], "rt");
FAILIF(radiiFile == NULL);
fscanf(radiiFile, "%d\n", &nRadii);
ASSERT(nRadii > 0);
FAILIF(NULL == (listOfRadii = (RealT*)MALLOC(nRadii * sizeof(RealT))));
FAILIF(NULL == (memRatiosForNNStructs = (RealT*)MALLOC(nRadii * sizeof(RealT))));
for(IntT i = 0; i < nRadii; i++)
{
FSCANF_REAL(radiiFile, &listOfRadii[i]);
ASSERT(listOfRadii[i] > 0);
FSCANF_REAL(radiiFile, &memRatiosForNNStructs[i]);
ASSERT(memRatiosForNNStructs[i] > 0);
}
}
else
{
nRadii = 1;
FAILIF(NULL == (listOfRadii = (RealT*)MALLOC(nRadii * sizeof(RealT))));
FAILIF(NULL == (memRatiosForNNStructs = (RealT*)MALLOC(nRadii * sizeof(RealT))));
listOfRadii[0] = thresholdR;
memRatiosForNNStructs[0] = 1;
}//对阈值R 和Radiii的处理
DPRINTF("No. radii: %d\n", nRadii);
//thresholdR = atof(args[5]);
availableTotalMemory = atoll(args[8]);//$M表示的是内存空间大小
if (nPoints > MAX_N_POINTS)
{
printf("Error: the structure supports at most %d points (%d were specified).\n", MAX_N_POINTS, nPoints);
fprintf(ERROR_OUTPUT, "Error: the structure supports at most %d points (%d were specified).\n", MAX_N_POINTS, nPoints);
exit(1);
}
readDataSetFromFile(args[6]);//点读到dataSetPoints
//这个totalAllocatedMemory初始化为0，但是
//#define MALLOC(amount) ((amount > 0) ? totalAllocatedMemory += amount, malloc(amount) : NULL)
//这样，每次申请内存都会统计到了
DPRINTF("Allocated memory (after reading data set): %lld\n", totalAllocatedMemory);
Int32T nSampleQueries = N_SAMPLE_QUERY_POINTS;
PPointT sampleQueries[N_SAMPLE_QUERY_POINTS];
Int32T sampleQBoundaryIndeces[N_SAMPLE_QUERY_POINTS];
// PPointT sampleQueries[nSampleQueries];
// Int32T sampleQBoundaryIndeces[nSampleQueries];
if ((nargs <= 9) || (strcmp("-c", args[9]) == 0) )
{
// In this cases, we need to generate a sample query set for
// computing the optimal parameters.
// Generate a sample query set.
FILE *queryFile = fopen(args[7], "rt");
if (strcmp(args[7], ".") == 0 || queryFile == NULL || nQueries <= 0)
{//没有查询文件，就用所有点产生随机点
// Choose several data set points for the sample query points.
for(IntT i = 0; i < nSampleQueries; i++){
sampleQueries[i] = dataSetPoints[genRandomInt(0, nPoints - 1)];
}
}
else
{
//从查询文件中选取随机的点，
// Choose several actual query points for the sample query points.
nSampleQueries = MIN(nSampleQueries, nQueries);
Int32T sampleIndeces[N_SAMPLE_QUERY_POINTS];
//Int32T sampleIndeces[nSampleQueries];
for(IntT i = 0; i < nSampleQueries; i++)
{
sampleIndeces[i] = genRandomInt(0, nQueries - 1);
}
qsort(sampleIndeces, nSampleQueries, sizeof(*sampleIndeces), compareInt32T);
//printIntVector("sampleIndeces: ", nSampleQueries, sampleIndeces);
Int32T j = 0;
for(Int32T i = 0; i < nQueries; i++)
{
if (i == sampleIndeces[j])
{
sampleQueries[j] = readPoint(queryFile);
j++;
while (i == sampleIndeces[j])
{
sampleQueries[j] = sampleQueries[j - 1];
j++;
}
}else
{
fscanf(queryFile, "%[^\n]", sBuffer);
fscanf(queryFile, "\n");
}
}
nSampleQueries = j;
fclose(queryFile);
}
//前面那么多，好像就是在申请内存，读文件，读入参数
// Compute the array sampleQBoundaryIndeces that specifies how to
// segregate the sample query points according to their distance
// to NN.
//采用遍历的方法，计算查询点的最近邻（并且距离小于listOfRadii【nRadii】）
sortQueryPointsByRadii(pointsDimension,
nSampleQueries,
sampleQueries,
nPoints,
dataSetPoints,
nRadii,
listOfRadii,
sampleQBoundaryIndeces);
}//if ((nargs < 9) || (strcmp("-c", args[9]) == 0))
RNNParametersT *algParameters = NULL;
PRNearNeighborStructT *nnStructs = NULL;
if (nargs > 9)
{/* 官方lsh文件：10个参数
bin/LSHMain $nDataSet $nQuerySet $dimension $successProbability "$1" "$2" "$3" $m -c
*/
// Additional command-line parameter is specified.
if (strcmp("-c", args[9]) == 0) //-c表示参数优化
{
// Only compute the R-NN DS parameters and output them to stdout.
printf("%d\n", nRadii);
transformMemRatios();
for(IntT i = 0; i < nRadii; i++)
{
// which sample queries to use
Int32T segregatedQStart = (i == 0) ? 0 : sampleQBoundaryIndeces[i - 1];
Int32T segregatedQNumber = nSampleQueries - segregatedQStart;
if (segregatedQNumber == 0)
{
// XXX: not the right answer
segregatedQNumber = nSampleQueries;
segregatedQStart = 0;
}
ASSERT(segregatedQStart < nSampleQueries);
ASSERT(segregatedQStart >= 0);
ASSERT(segregatedQStart + segregatedQNumber <= nSampleQueries);
ASSERT(segregatedQNumber >= 0);
//从文件读取点，然后计算优化后的参数
RNNParametersT optParameters = computeOptimalParameters(listOfRadii[i],
successProbability,
nPoints,
pointsDimension,
dataSetPoints,
segregatedQNumber,
sampleQueries + segregatedQStart,
/*对内存的约束，就体现在这里，
availableTotalMemory总共的内存（传入） - totalAllocatedMemory（使用mallloc分配的）*1=内存上限
然后(L * nPoints > memoryUpperBound / 12 来约束
*/
(MemVarT)((availableTotalMemory - totalAllocatedMemory) * memRatiosForNNStructs[i]));
printRNNParameters(stdout, optParameters);
}
exit(0);
}
else if (strcmp("-p", args[9]) == 0)
{//-p表示从文件读入参数，然后建立结构体
// Read the R-NN DS parameters from the given file and run the
// queries on the constructed data structure.
if (nargs < 10)
{
usage(args[0]);
exit(1);
}
FILE *pFile = fopen(args[10], "rt");
FAILIFWR(pFile == NULL, "Could not open the params file.");
fscanf(pFile, "%d\n", &nRadii);
DPRINTF1("Using the following R-NN DS parameters:\n");
DPRINTF("N radii = %d\n", nRadii);
FAILIF(NULL == (nnStructs = (PRNearNeighborStructT*)MALLOC(nRadii * sizeof(PRNearNeighborStructT))));
FAILIF(NULL == (algParameters = (RNNParametersT*)MALLOC(nRadii * sizeof(RNNParametersT))));
for(IntT i = 0; i < nRadii; i++)
{//默认i=1
algParameters[i] = readRNNParameters(pFile);//从文件读参数
printRNNParameters(stderr, algParameters[i]);
nnStructs[i] = initLSH_WithDataSet(algParameters[i], nPoints, dataSetPoints);
//核心
//初始化整个数据结构 包括整体+l个hash表 +点映射到桶
}
pointsDimension = algParameters[0].dimension;
FREE(listOfRadii);
FAILIF(NULL == (listOfRadii = (RealT*)MALLOC(nRadii * sizeof(RealT))));
for(IntT i = 0; i < nRadii; i++)
{
listOfRadii[i] = algParameters[i].parameterR;
}
}
else
{
// Wrong option.
usage(args[0]);
exit(1);
}
}//if (nargs > 9)
else
{
FAILIF(NULL == (nnStructs = (PRNearNeighborStructT*)MALLOC(nRadii * sizeof(PRNearNeighborStructT))));
// Determine the R-NN DS parameters, construct the DS and run the queries.
transformMemRatios();
for(IntT i = 0; i < nRadii; i++)
{
// XXX: segregate the sample queries...
//建立查询结构，自动优化参数
nnStructs[i] = initSelfTunedRNearNeighborWithDataSet(listOfRadii[i],
successProbability,
nPoints,
pointsDimension,
dataSetPoints,
nSampleQueries,
sampleQueries,
(MemVarT)((availableTotalMemory - totalAllocatedMemory) * memRatiosForNNStructs[i]));
}
} // if (nargs <= 9)
//上面都是根据不同配置，对参数的优化，建立查询结构
DPRINTF1("X\n");
IntT resultSize = nPoints;
PPointT *result = (PPointT*)MALLOC(resultSize * sizeof(*result));
PPointT queryPoint;
FAILIF(NULL == (queryPoint = (PPointT)MALLOC(sizeof(PointT))));
FAILIF(NULL == (queryPoint->coordinates = (RealT*)MALLOC(pointsDimension * sizeof(RealT))));
//读取查询点的文件
FILE *queryFile = fopen(args[7], "rt");
FAILIF(queryFile == NULL);
TimeVarT meanQueryTime = 0;
PPointAndRealTStructT *distToNN = NULL;
for(IntT i = 0; i < nQueries; i++)
{//对于每一个要查询的点
RealT sqrLength = 0;
// read in the query point.
for(IntT d = 0; d < pointsDimension; d++)
{
FSCANF_REAL(queryFile, &(queryPoint->coordinates[d]));
sqrLength += SQR(queryPoint->coordinates[d]);
/*//test
if (d >150 && d<160)
{
printf(" %lf ",queryPoint->coordinates[d]);
}
if ( d==160)
{
printf("原始的文件数据\n");
}
*/
}
queryPoint->sqrLength = sqrLength;
//printRealVector("Query: ", pointsDimension, queryPoint->coordinates);
// get the near neighbors.
IntT nNNs = 0;
for(IntT r = 0; r < nRadii; r++)
{//查询n个近邻点，并计算距离
//查询核心
nNNs = getRNearNeighbors(nnStructs[r], queryPoint, result, resultSize);
printf("Total time for R-NN query at radius %0.6lf (radius no. %d):\t%0.6lf\n", (double)(listOfRadii[r]), r, timeRNNQuery);
meanQueryTime += timeRNNQuery;
if (nNNs > 0)
{
printf("Query point %d: found %d NNs at distance %0.6lf (%dth radius). First %d NNs are:\n",
i, nNNs, (double)(listOfRadii[r]), r, MIN(nNNs, MAX_REPORTED_POINTS));
// compute the distances to the found NN, and sort according to the distance
//计算近邻点和查询点的距离
FAILIF(NULL == (distToNN = (PPointAndRealTStructT*)REALLOC(distToNN, nNNs * sizeof(*distToNN))));
for(IntT p = 0; p < nNNs; p++)
{
distToNN[p].ppoint = result[p];
distToNN[p].real = distance(pointsDimension, queryPoint, result[p]);
}
qsort(distToNN, nNNs, sizeof(*distToNN), comparePPointAndRealTStructT);
// Print the points
for(IntT j = 0; j < MIN(nNNs, MAX_REPORTED_POINTS); j++)
{
ASSERT(distToNN[j].ppoint != NULL);
printf("%09d\tDistance:%0.6lf\n", distToNN[j].ppoint->index, distToNN[j].real);
CR_ASSERT(distToNN[j].real <= listOfRadii[r]);
//DPRINTF("Distance: %lf\n", distance(pointsDimension, queryPoint, result[j]));
//printRealVector("NN: ", pointsDimension, result[j]->coordinates);
}
break;
}
}
if (nNNs == 0)
{
printf("Query point %d: no NNs found.\n", i);
}
}// for(IntT i = 0; i < nQueries; i++)每个点查询
//
if (nQueries > 0)
{
meanQueryTime = meanQueryTime / nQueries;
printf("Mean query time: %0.6lf\n", (double)meanQueryTime);
}
for(IntT i = 0; i < nRadii; i++)
{
freePRNearNeighborStruct(nnStructs[i]);
}
// XXX: should ideally free the other stuff as well.
return 0;
}
static void
line_handler(char *line)
{
char *rewritten_line, *filtered_line;
if (line == NULL) { /* EOF on input, forward it */
DPRINTF1(DEBUG_READLINE, "EOF detected, writing character %d", term_eof);
/* colour_the_prompt = FALSE; don't mess with the cruft that may come out of dying command @@@ but command may not die!*/
write_EOF_to_master_pty();
} else {
if (*line && /* forget empty lines */
redisplay && /* forget passwords */
!forget_line && /* forget lines entered by CTRL-O */
!match_regexp(line, forget_regexp, TRUE)) { /* forget lines (case-inseitively) matching -g option regexp */
my_add_history(line);
}
forget_line = FALSE; /* until CTRL-O is used again */
/* Time for a design decision: when we send the accepted line to the client command, it will most probably be echoed
back. We have two choices: we leave the entered line on screen and suppress just enough of the clients output (I
believe this is what rlfe does), or we remove the entered input (but not the prompt!) and let it be replaced by
the echo.
This is what we do; as a bonus, if the program doesn't echo, e.g. at a password prompt, the **** which has been
put there by our homegrown_redisplay function will be removed (@@@is this what we want?)
I think this method is more natural for multi-line input as well, (we will actually see our multi-line input as
multiple lines) but not everyone will agree with that.
O.K, we know for sure that cursor is at start of line. When clients output arrives, it will be printed at
just the right place - but first we 'll erase the user input (as it may be about to be changed by the filter) */
rl_delete_text(0, rl_end); /* clear line (after prompt) */
rl_point = 0;
my_redisplay(); /* and redisplay (this time without user input, cf the comments for the line_handler() function below) */
rewritten_line =
(multiline_separator ?
search_and_replace(multiline_separator, "\n", line, 0, NULL,
NULL) : mysavestring(line));
if (redisplay)
filtered_line = pass_through_filter(TAG_INPUT, rewritten_line);
else { /* password, none of filters business */
pass_through_filter(TAG_INPUT, "***"); /* filter some input anyway, to keep filter in sync (result is discarded). */
filtered_line = mysavestring(rewritten_line);
}
free(rewritten_line);
/* do we have to adapt clients winzsize now? */
if (deferred_adapt_commands_window_size) {
adapt_tty_winsize(STDIN_FILENO, master_pty_fd);
kill(-command_pid, SIGWINCH);
deferred_adapt_commands_window_size = FALSE;
}
/*OK, now feed line to underlying command and wait for the echo to come back */
put_in_output_queue(filtered_line);
DPRINTF2(DEBUG_READLINE, "putting %d bytes %s in output queue", (int) strlen(rewritten_line),
mangle_string_for_debug_log(rewritten_line, 40));
write_EOL_to_master_pty(return_key ? &return_key : "\n");
accepted_lines++;
free_foreign(line); /* free_foreign because line was malloc'ed by readline, not by rlwrap */
free(filtered_line); /* we're done with them */
return_key = 0;
within_line_edit = FALSE;
if(!RL_ISSTATE(RL_STATE_MACROINPUT)) /* when called during playback of a multi-line macro, line_handler() will be called more
than once whithout re-entering main_loop(). If we'd remove it here, the second call
would crash */
rl_callback_handler_remove();
set_echo(FALSE);
free(saved_rl_state.input_buffer);
free(saved_rl_state.raw_prompt);
free(saved_rl_state.cooked_prompt);
saved_rl_state.input_buffer = mysavestring("");
saved_rl_state.raw_prompt = mysavestring("");
saved_rl_state.cooked_prompt = NULL;
saved_rl_state.point = 0;
saved_rl_state.already_saved = TRUE;
redisplay = TRUE;
if (one_shot_rlwrap)
write_EOF_to_master_pty();
}
}
static void
log_named_signal(int signo)
{
if (debug)
DPRINTF1(DEBUG_SIGNALS, "got %s", signal_name(signo));
}
static int
is_server_running(rmedia_handle_t *handle)
{
door_arg_t door_args;
smedia_reqping_t reqping;
smedia_retping_t *retping;
int ret_val;
int door_fd;
CLIENT *clnt;
char rbuf[sizeof (smedia_services_t) + sizeof (door_desc_t)];
smserver_info *server_info;
/*
* We will assume that we are running at level 2 or greater
* and attempt to contact the server using RPC mecahnisms.
* If that fails then we will attempt to contact the server
* using non-rpc mechanism. This will enable the libsmedia
* to be used in SINGLE user mode when inetd is not running.
* We expect the server to have been started manually by user.
*
* Note that "localhost" is used (vs hostname (eg, "uname -n")),
* as this minimizes interference with common IPSec rules.
*/
clnt = clnt_create("localhost", SMSERVERPROG, SMSERVERVERS,
"circuit_v");
if (clnt == (CLIENT *)NULL) {
/*
* The failure could be that we are running at level 1
*/
door_fd = open(smedia_service, O_RDONLY, 0644);
if (door_fd < 0) {
DPRINTF1("Error in opening %s\n",
smedia_service);
return (0);
}
DPRINTF1("rbuf address=%p\n", rbuf);
reqping.cnum = SMEDIA_CNUM_PING;
door_args.data_ptr = (char *)&reqping;
door_args.data_size = sizeof (smedia_services_t);
door_args.desc_ptr = NULL;
door_args.desc_num = 0;
door_args.rbuf = rbuf;
door_args.rsize = sizeof (rbuf);
ret_val = door_call(door_fd, &door_args);
(void) close(door_fd);
if (ret_val < 0) {
return (0);
}
DPRINTF3("rsize = %d data_size = %d data_ptr = %p \n",
door_args.rsize, door_args.data_size,
door_args.data_ptr);
retping = (smedia_retping_t *)(
(void *)door_args.data_ptr);
if (retping->cnum != SMEDIA_CNUM_PING) {
DPRINTF1("*** door call failed *** cnum "
"returned = 0x%x\n", retping->cnum);
return (0);
}
return (1);
}
server_info = smserverproc_get_serverinfo_1(NULL, clnt);
if (server_info == NULL) {
if (clnt)
clnt_destroy(clnt);
return (0);
}
if (server_info->status != 0) {
if (clnt)
clnt_destroy(clnt);
DPRINTF1("get server_info call failed. "
"status = %d\n", server_info->status);
return (0);
}
if (server_info->vernum != SMSERVERVERS) {
if (clnt)
clnt_destroy(clnt);
DPRINTF2("version expected = %d version "
"returned = %d\n", SMSERVERVERS,
server_info->vernum);
return (0);
}
door_fd = open(smedia_service, O_RDONLY, 0644);
if (door_fd < 0) {
DPRINTF1("Error in opening %s\n", smedia_service);
return (0);
}
DPRINTF1("rbuf address=%p\n", rbuf);
reqping.cnum = SMEDIA_CNUM_PING;
door_args.data_ptr = (char *)&reqping;
door_args.data_size = sizeof (smedia_services_t);
door_args.desc_ptr = NULL;
door_args.desc_num = 0;
door_args.rbuf = rbuf;
door_args.rsize = sizeof (rbuf);
ret_val = door_call(door_fd, &door_args);
(void) close(door_fd);
if (ret_val < 0) {
return (0);
}
DPRINTF3("rsize = %d data_size = %d data_ptr = %p \n",
door_args.rsize, door_args.data_size,
door_args.data_ptr);
retping = (smedia_retping_t *)((void *)door_args.data_ptr);
if (retping->cnum != SMEDIA_CNUM_PING) {
DPRINTF1("*** door call failed *** cnum returned "
"= 0x%x\n", retping->cnum);
return (0);
}
handle->sm_clnt = clnt;
return (1);
}
smedia_handle_t
get_handle_from_fd(int32_t fd)
{
rmedia_handle_t *handle;
void *lib_handle;
int door_fd, door_server;
int ret_val;
door_arg_t door_args;
smedia_reqopen_t reqopen;
smedia_reterror_t *reterror;
door_desc_t ddesc[2];
char rbuf[sizeof (smedia_services_t) + sizeof (door_desc_t)];
struct stat stat;
DPRINTF("smedia_get_handle called\n");
handle = (rmedia_handle_t *)malloc(sizeof (rmedia_handle_t));
if (handle == NULL) {
DPRINTF("Could not allocate memory for handle\n");
return (NULL);
}
(void) memset((void *) handle, 0, sizeof (rmedia_handle_t));
handle->sm_fd = -1;
handle->sm_door = -1;
handle->sm_death_door = -1;
handle->sm_buffd = -1;
handle->sm_buf = NULL;
handle->sm_bufsize = 0;
if (ioctl(fd, DKIOCINFO, &handle->sm_dkinfo) == -1) {
free(handle);
PERROR("DKIOCINFO failed");
return (NULL);
}
lib_handle = get_dev_library_handle(fd);
if (lib_handle == NULL) {
free(handle);
DPRINTF("lib_Handle is NULL\n");
errno = ENOTSUP;
return (NULL);
}
DPRINTF("Handle initialised successfully.\n");
/* Initialise the handle elements */
handle->sm_lib_handle = lib_handle;
handle->sm_signature = LIBSMEDIA_SIGNATURE;
DPRINTF2("fd=%d signature=0x%x\n", handle->sm_fd, handle->sm_signature);
if ((handle->sm_dkinfo.dki_ctype == DKC_SCSI_CCS) ||
(handle->sm_dkinfo.dki_ctype == DKC_MD21) ||
(handle->sm_dkinfo.dki_ctype == DKC_CDROM)) {
ret_val = is_server_running(handle);
if (ret_val == 0) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
return (NULL);
}
door_fd = open(smedia_service, O_RDONLY, 0644);
if (door_fd < 0) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
DPRINTF1("Error in opening %s\n", smedia_service);
PERROR(smedia_service);
return (NULL);
}
DPRINTF1("rbuf address=%p\n", rbuf);
ddesc[0].d_data.d_desc.d_descriptor = fd;
ddesc[0].d_attributes = DOOR_DESCRIPTOR;
reqopen.cnum = SMEDIA_CNUM_OPEN_FD;
door_args.data_ptr = (char *)&reqopen;
door_args.data_size = sizeof (smedia_services_t);
door_args.desc_ptr = &ddesc[0];
door_args.desc_num = 1;
door_args.rbuf = rbuf;
door_args.rsize = sizeof (rbuf);
ret_val = door_call(door_fd, &door_args);
(void) close(door_fd);
if (ret_val < 0) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
PERROR("door_call");
return (NULL);
}
DPRINTF3("rsize = %d data_size = %d data_ptr = %p \n",
door_args.rsize, door_args.data_size,
door_args.data_ptr);
reterror = (smedia_reterror_t *)((void *)door_args.data_ptr);
if (reterror->cnum != SMEDIA_CNUM_OPEN_FD) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
DPRINTF1(
"*** door call failed *** cnum returned = 0x%x\n", reterror->cnum);
errno = reterror->errnum;
return (NULL);
}
/*
* 2 door descriptors are returned after the above door call.
* The first door descriptor is the one that will be used
* in subsequent smedia calls. A dedicated thread is
* associated with this door to handle client calls.
* The second door descriptor is needed to signal unexpected
* death of the client to the server. This will help the server
* to do the necessary cleanup.
*/
if (door_args.desc_num != 2) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
DPRINTF("Num of door descriptors returned by "
"server is not 2");
if (door_args.desc_num)
(void) close(door_args.desc_ptr->\
d_data.d_desc.d_descriptor);
return (NULL);
}
door_server = door_args.desc_ptr->d_data.d_desc.d_descriptor;
/* Check if the descriptor returned is S_IFDOOR */
if (fstat(door_server, &stat) < 0) {
PERROR("fstat");
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
return (NULL);
}
if (!S_ISDOOR(stat.st_mode)) {
DPRINTF(
"Descriptor returned by door_call is not of type DOOR\n");
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
return (NULL);
}
handle->sm_door = door_server;
handle->sm_fd = fd;
door_args.desc_ptr++;
handle->sm_death_door =
door_args.desc_ptr->d_data.d_desc.d_descriptor;
DPRINTF("door call succeeded.\n");
return ((smedia_handle_t)handle);
} else {
handle->sm_fd = fd;
return ((smedia_handle_t)handle);
}
}
void spawn_filter(const char *filter_command) {
int input_pipe_fds[2];
int output_pipe_fds[2];
mypipe(input_pipe_fds);
filter_input_fd = input_pipe_fds[1]; /* rlwrap writes filter input to this */
mypipe(output_pipe_fds);
filter_output_fd = output_pipe_fds[0]; /* rlwrap reads filter output from here */
DPRINTF1(DEBUG_FILTERING, "preparing to spawn filter <%s>", filter_command);
assert(!command_pid || signal_handlers_were_installed); /* if there is a command, then signal handlers are installed */
if ((filter_pid = fork()) < 0)
myerror(FATAL|USE_ERRNO, "Cannot spawn filter '%s'", filter_command);
else if (filter_pid == 0) { /* child */
int signals_to_allow[] = {SIGPIPE, SIGCHLD, SIGALRM, SIGUSR1, SIGUSR2};
char **argv;
unblock_signals(signals_to_allow); /* when we run a pager from a filter we want to catch these */
DEBUG_RANDOM_SLEEP;
i_am_child = TRUE;
/* set environment for filter (it needs to know at least the file descriptors for its input and output) */
if (!getenv("RLWRAP_FILTERDIR"))
mysetenv("RLWRAP_FILTERDIR", add2strings(DATADIR,"/rlwrap/filters"));
mysetenv("PATH", add3strings(getenv("RLWRAP_FILTERDIR"),":",getenv("PATH")));
mysetenv("RLWRAP_VERSION", VERSION);
mysetenv("RLWRAP_COMMAND_PID", as_string(command_pid));
mysetenv("RLWRAP_COMMAND_LINE", command_line);
if (impatient_prompt)
mysetenv("RLWRAP_IMPATIENT", "1");
mysetenv("RLWRAP_INPUT_PIPE_FD", as_string(input_pipe_fds[0]));
mysetenv("RLWRAP_OUTPUT_PIPE_FD", as_string(output_pipe_fds[1]));
mysetenv("RLWRAP_MASTER_PTY_FD", as_string(master_pty_fd));
close(filter_input_fd);
close(filter_output_fd);
if (scan_metacharacters(filter_command, "'|\"><")) { /* if filter_command contains shell metacharacters, let the shell unglue them */
char *exec_command = add3strings("exec", " ", filter_command);
argv = list4("sh", "-c", exec_command, NULL);
} else { /* if not, split and feed to execvp directly (cheaper, better error message) */
argv = split_with(filter_command, " ");
}
assert(argv[0]);
if(execvp(argv[0], argv) < 0) {
char *sorry = add3strings("Cannot exec filter '", argv[0], add2strings("': ", strerror(errno)));
write_message(output_pipe_fds[1], TAG_ERROR, sorry, "to stdout"); /* this will kill rlwrap */
mymicrosleep(100 * 1000); /* 100 sec for rlwrap to go away should be enough */
exit (-1);
}
assert(!"not reached");
} else {
DEBUG_RANDOM_SLEEP;
signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE - we have othere ways to deal with filter death */
DPRINTF1(DEBUG_FILTERING, "spawned filter with pid %d", filter_pid);
close (input_pipe_fds[0]);
close (output_pipe_fds[1]);
}
}
// Determines the run-time coefficients of the different parts of the //确定查询算法不同部分的运行时间
// query algorithm. Values that are computed and returned are
// <lshPrecomp>, <uhashOver>, <distComp>. <lshPrecomp> is the time for
// pre-computing one function from the LSH family. <uhashOver> is the
// time for getting a bucket from a hash table (of buckets).<distComp>
// is the time to compute one distance between two points. These times
// are computed by constructing a R-NN DS on a sample data set and
// running a sample query set on it.
void determineRTCoefficients(RealT thresholdR,
RealT successProbability,
BooleanT useUfunctions,
IntT typeHT, //建立hash表的类型
IntT dimension,
Int32T nPoints,
PPointT *realData,
RealT &lshPrecomp,
RealT &uhashOver,
RealT &distComp){
// use a subset of the original data set. 使用原始数据集的一个子集
// there is not much theory behind the formula below. //减小运算规模
IntT n = nPoints / 50; //最多生成n各点，缩小50倍
if (n < 100) { //如果生成的点的个数小于100，则使桶的数量与数据集点的数量一样多
n = nPoints;
}
if (n > 10000) {
n = 10000;
}
// Initialize the data set to use.
PPointT *dataSet;
FAILIF(NULL == (dataSet = (PPointT*)MALLOC(n * sizeof(PPointT))));
for(IntT i = 0; i < n; i++){ //从真实数据集中随机取n个点 （最多10000个）
dataSet[i] = realData[genRandomInt(0, nPoints - 1)];
}
IntT hashTableSize = n; //哈希表大小也初始化为n，是指hashTableSize放的点的个数，还是放的桶的个数？
RNNParametersT algParameters;
algParameters.parameterR = thresholdR; //半径
algParameters.successProbability = successProbability;
algParameters.dimension = dimension;
#ifdef USE_L1_DISTANCE
algParameters.parameterR2 = thresholdR; //使用L1距离，R2=R
#else
algParameters.parameterR2 = SQR(thresholdR); //使用L2 R2=R^2
#endif
algParameters.useUfunctions = useUfunctions;
algParameters.parameterK = 16; //k 设定为16，只是测试，估算运算时间，可能是先随机设置一个时间，之后再在代码中改成16，因为16是bestK.
algParameters.parameterW = PARAMETER_W_DEFAULT; //W=4，manuel中说经过多次测试，4是最好的值
algParameters.parameterT = n; //点的个数
algParameters.typeHT = typeHT; //桶的类型HT_HYBRID_CHAINS，在line405里面定义的。
if (algParameters.useUfunctions){
algParameters.parameterM = computeMForULSH(algParameters.parameterK, algParameters.successProbability); //经过改进的L和M
algParameters.parameterL = algParameters.parameterM * (algParameters.parameterM - 1) / 2;
}else{
algParameters.parameterM = computeLfromKP(algParameters.parameterK, algParameters.successProbability); //论文里面的M=L
algParameters.parameterL = algParameters.parameterM;
}
// FAILIF(NULL == (dataSet = (PPointT*)MALLOC(n * sizeof(PPointT))));
// for(IntT i = 0; i < n; i++){
// FAILIF(NULL == (dataSet[i] = (PPointT)MALLOC(sizeof(PointT))));
// FAILIF(NULL == (dataSet[i]->coordinates = (RealT*)MALLOC(dimension * sizeof(RealT))));
// dataSet[i]->index = i;
// sqrLength = 0;
// for(IntT d = 0; d < dimension; d++){
// if (i == 0) {
// dataSet[i]->coordinates[d] = genUniformRandom(-100, 100);
// }else{
// dataSet[i]->coordinates[d] = dataSet[0]->coordinates[d];
// }
// sqrLength += SQR(dataSet[i]->coordinates[d]);
// }
// dataSet[i]->sqrLength = sqrLength;
// }
// switch on timing
BooleanT tempTimingOn = timingOn; //初始化为True
timingOn = TRUE;
// initialize result arrays
PPointT *result = NULL; //结果集以及其初始化
IntT resultSize = 0;
IntT nNNs;
IntT nSucReps;
do{
// create the test structure
PRNearNeighborStructT nnStruct;
switch(algParameters.typeHT){
case HT_LINKED_LIST:
nnStruct = initLSH(algParameters, n);
// add points to the test structure
for(IntT i = 0; i < n; i++){
addNewPointToPRNearNeighborStruct(nnStruct, realData[i]);
}
break;
case HT_HYBRID_CHAINS:
nnStruct = initLSH_WithDataSet(algParameters, n, dataSet); //初始化数据结构，参数集，点的个数，数据集，对点进行映射转换，桶进行映射转换，点存入桶中
break;
default:
ASSERT(FALSE);
}
// query point
PPointT queryPoint;
// FAILIF(NULL == (queryPoint = (PPointT)MALLOC(sizeof(PointT))));
// FAILIF(NULL == (queryPoint->coordinates = (RealT*)MALLOC(dimension * sizeof(RealT))));
// RealT sqrLength = 0;
// for(IntT i = 0; i < dimension; i++){
// queryPoint->coordinates[i] = dataSet[0]->coordinates[i];
// //queryPoint->coordinates[i] = 0.1;
// sqrLength += SQR(queryPoint->coordinates[i]);
// }
//queryPoint->coordinates[0] = dataPoint->coordinates[0] + 0.0001;
//queryPoint->sqrLength = sqrLength;
// reset the R parameter so that there are no NN neighbors.
setResultReporting(nnStruct, FALSE);
//DPRINTF1("X\n");
lshPrecomp = 0;
uhashOver = 0;
distComp = 0;
IntT nReps = 20;
nSucReps = 0;
for(IntT rep = 0; rep < nReps; rep++){
queryPoint = realData[genRandomInt(0, nPoints - 1)]; //查询点为数据集中随机抽取出来的一个点
timeComputeULSH = 0;
timeGetBucket = 0;
timeCycleBucket = 0;
nOfDistComps = 0; //点与点比较的次数
//返回查找到的近邻点数，并将查询到的近邻点存入result中。
nNNs = getNearNeighborsFromPRNearNeighborStruct(nnStruct, queryPoint, result, resultSize);
//DPRINTF("Time to compute LSH: %0.6lf\n", timeComputeULSH);
//DPRINTF("Time to get bucket: %0.6lf\n", timeGetBucket);
//DPRINTF("Time to cycle through buckets: %0.9lf\n", timeCycleBucket);
//DPRINTF("N of dist comp: %d\n", nOfDistComps);
ASSERT(nNNs == 0); //若一个点都没有找到，将发生中断。
if (nOfDistComps >= MIN(n / 10, 100)){ //与足够的点比较过，才将时间计入
nSucReps++;
lshPrecomp += timeComputeULSH / algParameters.parameterK / algParameters.parameterM; //一个点对一个哈希函数的处理时间。共有k*L个哈希函数
uhashOver += timeGetBucket / algParameters.parameterL; //找到一个链表中桶的时间
distComp += timeCycleBucket / nOfDistComps; //遍历链表中桶，并与桶里面的点比较的时间
}
}
if (nSucReps >= 5){
lshPrecomp /= nSucReps;
uhashOver /= nSucReps;
distComp /= nSucReps;
DPRINTF1("RT coeffs computed.\n");
}else{
algParameters.parameterR *= 2; // double the radius and repeat //比较的点数不够，将半径扩大，重复比较
DPRINTF1("Could not determine the RT coeffs. Repeating.\n");
}
freePRNearNeighborStruct(nnStruct);
}while(nSucReps < 5); //做一个有效值的判断，要获得5次有效值
FREE(dataSet);
FREE(result);
timingOn = tempTimingOn;
}
