static void
navit_debug(struct navit *this_)
{
#if 0
#include "attr.h"
#include "item.h"
#include "search.h"
struct attr attr;
struct search_list *sl;
struct search_list_result *res;
debug_level_set("data_mg:town_search_get_item",1);
debug_level_set("data_mg:town_search_compare",1);
debug_level_set("data_mg:tree_search_next",1);
sl=search_list_new(this_->mapsets->data);
attr.type=attr_country_all;
attr.u.str="Deu";
search_list_search(sl, &attr, 1);
while (res=search_list_get_result(sl)) {
printf("country result\n");
}
attr.type=attr_town_name;
attr.u.str="U";
search_list_search(sl, &attr, 1);
while (res=search_list_get_result(sl)) {
printf("town result\n");
}
search_list_destroy(sl);
#endif
}
struct debug *
debug_new(struct attr *parent, struct attr **attrs)
{
struct attr *name, *level;
name = attr_search(attrs, NULL, attr_name);
level = attr_search(attrs, NULL, attr_level);
#ifdef HAVE_SOCKET
if (!name && !level)
{
struct attr *socket_attr=attr_search(attrs, NULL, attr_socket);
char *p,*s;
if (!socket_attr)
return NULL;
s=g_strdup(socket_attr->u.str);
p=strchr(s,':');
if (!p)
{
g_free(s);
return NULL;
}
*p++='\0';
debug_sin.sin_family=AF_INET;
if (!inet_aton(s, &debug_sin.sin_addr))
{
g_free(s);
return NULL;
}
debug_sin.sin_port=ntohs(atoi(p));
if (debug_socket == -1)
debug_socket=socket(PF_INET, SOCK_DGRAM, 0);
g_free(s);
return (struct debug *)&dummy;
}
#endif
if (!name || !level)
return NULL;
debug_level_set(name->u.str, level->u.num);
return (struct debug *) &dummy;
}
int main (int argc, char ** argv)
{
time_t tm;
int i, new_mudlib = 0, got_defaults = 0;
char *p;
char version_buf[80];
#if 0
int dtablesize;
#endif
error_context_t econ;
#ifdef PROTO_TZSET
void tzset();
#endif
#ifdef INCL_LOCALE_H
setlocale(LC_ALL, "C");
#endif
#if !defined(__SASC) && (defined(AMITCP) || defined(AS225))
amiga_sockinit();
atexit(amiga_sockexit);
#endif
#ifdef WRAPPEDMALLOC
wrappedmalloc_init();
#endif /* WRAPPEDMALLOC */
#ifdef DEBUGMALLOC
MDinit();
#endif
#if (defined(PROFILING) && !defined(PROFILE_ON) && defined(HAS_MONCONTROL))
moncontrol(0);
#endif
#ifdef USE_TZSET
tzset();
#endif
boot_time = get_current_time();
const0.type = T_NUMBER;
const0.u.number = 0;
const1.type = T_NUMBER;
const1.u.number = 1;
/* const0u used by undefinedp() */
const0u.type = T_NUMBER;
const0u.subtype = T_UNDEFINED;
const0u.u.number = 0;
//fake_prog.program_size = 0; //0 anyway
/*
* Check that the definition of EXTRACT_UCHAR() is correct.
*/
p = (char *) &i;
*p = -10;
if (EXTRACT_UCHAR(p) != 0x100 - 10) {
fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in interpret.h.\n");
exit(-1);
}
/*
* An added test: can we do EXTRACT_UCHAR(x++)?
* (read_number, etc uses it)
*/
p = (char *) &i;
(void) EXTRACT_UCHAR(p++);
if ((p - (char *) &i) != 1) {
fprintf(stderr, "EXTRACT_UCHAR() in interpret.h evaluates its argument more than once.\n");
exit(-1);
}
/*
* Check the living hash table size
*/
if (CFG_LIVING_HASH_SIZE != 4 && CFG_LIVING_HASH_SIZE != 16 &&
CFG_LIVING_HASH_SIZE != 64 && CFG_LIVING_HASH_SIZE != 256 &&
CFG_LIVING_HASH_SIZE != 1024 && CFG_LIVING_HASH_SIZE != 4096) {
fprintf(stderr, "CFG_LIVING_HASH_SIZE in options.h must be one of 4, 16, 64, 256, 1024, 4096, ...\n");
exit(-1);
}
#ifdef RAND
srand(get_current_time());
#else
# ifdef DRAND48
srand48(get_current_time());
# else
# ifdef RANDOM
srandom(get_current_time());
# else
fprintf(stderr, "Warning: no random number generator specified!\n");
# endif
# endif
#endif
current_time = get_current_time();
/*
* Initialize the microsecond clock.
*/
init_usec_clock();
/* read in the configuration file */
got_defaults = 0;
for (i = 1; (i < argc) && !got_defaults; i++) {
if (argv[i][0] != '-') {
set_defaults(argv[i]);
got_defaults = 1;
}
}
get_version(version_buf);
if (!got_defaults) {
fprintf(stderr, "%s for %s.\n", version_buf, ARCH);
fprintf(stderr, "You must specify the configuration filename as an argument.\n");
exit(-1);
}
printf("Initializing internal tables....\n");
init_strings(); /* in stralloc.c */
init_otable(); /* in otable.c */
init_identifiers(); /* in lex.c */
init_locals(); /* in compiler.c */
/*
* If our estimate is larger than FD_SETSIZE, then we need more file
* descriptors than the operating system can handle. This is a problem
* that can be resolved by decreasing MAX_USERS, MAX_EFUN_SOCKS, or both.
*
* Unfortunately, since neither MAX_USERS or MAX_EFUN_SOCKS exist any more,
* we have no clue how many we will need. This code really should be
* moved to places where ENFILE/EMFILE is returned.
*/
#if 0
if (dtablesize > FD_SETSIZE) {
fprintf(stderr, "Warning: File descriptor requirements exceed system capacity!\n");
fprintf(stderr, " Configuration exceeds system capacity by %d descriptor(s).\n",
dtablesize - FD_SETSIZE);
}
#ifdef HAS_SETDTABLESIZE
/*
* If the operating system supports setdtablesize() then we can request
* the number of file descriptors we really need. First check to see if
* wee already have enough. If so dont bother the OS. If not, attempt to
* allocate the number we estimated above. There are system imposed
* limits on file descriptors, so we may not get as many as we asked for.
* Check to make sure we get enough.
*/
if (getdtablesize() < dtablesize)
if (setdtablesize(dtablesize) < dtablesize) {
fprintf(stderr, "Warning: Could not allocate enough file descriptors!\n");
fprintf(stderr, " setdtablesize() could not allocate %d descriptor(s).\n",
getdtablesize() - dtablesize);
}
/*
* Just be polite and tell the administrator how many he has.
*/
fprintf(stderr, "%d file descriptors were allocated, (%d were requested).\n",
getdtablesize(), dtablesize);
#endif
#endif
time_to_clean_up = TIME_TO_CLEAN_UP;
max_cost = MAX_COST;
reserved_size = RESERVED_SIZE;
max_array_size = MAX_ARRAY_SIZE;
if(max_array_size > 65535){
fprintf(stderr, "Maximum array size can not exceed 65535");
max_array_size = 65535;
}
max_buffer_size = MAX_BUFFER_SIZE;
max_string_length = MAX_STRING_LENGTH;
mud_lib = (char *) MUD_LIB;
set_inc_list(INCLUDE_DIRS);
if (reserved_size > 0)
reserved_area = (char *) DMALLOC(reserved_size, TAG_RESERVED, "main.c: reserved_area");
for (i = 0; i < sizeof consts / sizeof consts[0]; i++)
consts[i] = exp(-i / 900.0);
reset_machine(1);
/*
* The flags are parsed twice ! The first time, we only search for the -m
* flag, which specifies another mudlib, and the D-flags, so that they
* will be available when compiling master.c.
*/
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-')
continue;
switch (argv[i][1]) {
case 'D':
if (argv[i][2]) {
lpc_predef_t *tmp = ALLOCATE(lpc_predef_t, TAG_PREDEFINES,
"predef");
tmp->flag = argv[i] + 2;
tmp->next = lpc_predefs;
lpc_predefs = tmp;
continue;
}
fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]);
exit(-1);
case 'N':
no_ip_demon++;
continue;
#ifdef HAS_CONSOLE
case 'C':
has_console = 1;
continue;
#endif
#ifdef YYDEBUG
case 'y':
yydebug = 1;
continue;
#endif /* YYDEBUG */
case 'm':
mud_lib = alloc_cstring(argv[i] + 2, "mudlib dir");
if (chdir(mud_lib) == -1) {
fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib);
exit(-1);
}
new_mudlib = 1;
break;
}
}
if (!new_mudlib && chdir(mud_lib) == -1) {
fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib);
exit(-1);
}
time(&tm);
debug_message("----------------------------------------------------------------------------\n%s (%s) starting up on %s - %s\n\n", MUD_NAME, version_buf, ARCH, ctime(&tm));
add_predefines();
#ifdef WIN32
_tzset();
#endif
#ifndef NO_IP_DEMON
if (!no_ip_demon && ADDR_SERVER_IP)
init_addr_server(ADDR_SERVER_IP, ADDR_SERVER_PORT);
#endif /* NO_IP_DEMON */
set_eval(max_cost);
save_context(&econ);
if (SETJMP(econ.context)) {
debug_message("The simul_efun (%s) and master (%s) objects must be loadable.\n",
SIMUL_EFUN, MASTER_FILE);
exit(-1);
} else {
init_simul_efun(SIMUL_EFUN);
init_master();
}
pop_context(&econ);
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
continue;
} else {
/*
* Look at flags. -m and -o has already been tested.
*/
switch (argv[i][1]) {
case 'D':
case 'N':
case 'm':
case 'y':
case 'C':
continue;
case 'f':
save_context(&econ);
if (SETJMP(econ.context)) {
debug_message("Error while calling master::flag(\"%s\"), aborting ...\n", argv[i] + 2);
exit(-1);
}
push_constant_string(argv[i] + 2);
apply_master_ob(APPLY_FLAG, 1);
if (MudOS_is_being_shut_down) {
debug_message("Shutdown by master object.\n");
exit(0);
}
pop_context(&econ);
continue;
case 'e':
e_flag++;
continue;
case 'p':
external_port[0].port = atoi(argv[i] + 2);
continue;
case 'd':
#ifdef DEBUG_MACRO
if (argv[i][2])
debug_level_set(&argv[i][2]);
else
debug_level |= DBG_d_flag;
#else
debug_message("Driver must be compiled with DEBUG_MACRO on to use -d.\n");
#endif
break;
case 'c':
comp_flag++;
continue;
case 't':
t_flag++;
continue;
default:
debug_message("Unknown flag: %s\n", argv[i]);
exit(-1);
}
}
}
if (MudOS_is_being_shut_down)
exit(1);
if (*(DEFAULT_FAIL_MESSAGE)) {
char buf[8192];
strcpy(buf, DEFAULT_FAIL_MESSAGE);
strcat(buf, "\n");
default_fail_message = make_shared_string(buf);
} else
default_fail_message = "What?\n";
#ifdef PACKAGE_MUDLIB_STATS
restore_stat_files();
#endif
preload_objects(e_flag);
#ifdef SIGFPE
signal(SIGFPE, sig_fpe);
#endif
#ifdef TRAP_CRASHES
#ifdef SIGUSR1
signal(SIGUSR1, sig_usr1);
#endif
#ifdef SIGUSR2
signal(SIGUSR2, sig_usr2);
#endif
signal(SIGTERM, sig_term);
signal(SIGINT, sig_int);
#ifndef DEBUG
#if defined(SIGABRT)
signal(SIGABRT, sig_abrt);
#endif
#ifdef SIGIOT
signal(SIGIOT, sig_iot);
#endif
#ifdef SIGHUP
signal(SIGHUP, sig_hup);
#endif
#ifdef SIGBUS
signal(SIGBUS, sig_bus);
#endif
signal(SIGSEGV, sig_segv);
signal(SIGILL, sig_ill);
#endif /* DEBUG */
#endif
#ifndef WIN32
#ifdef USE_BSD_SIGNALS
signal(SIGCHLD, sig_cld);
#else
signal(SIGCLD, sig_cld);
#endif
#endif
#ifdef HAS_CONSOLE
if(has_console >= 0)
signal(SIGTTIN, sig_ttin);
signal(SIGTTOU, SIG_IGN);
#endif
backend();
return 0;
}
int main(int argc, char *argv[])
{
//////////////////////////////////////////////////////////////////////
// Handel argument
if (argc != 4) {
usage(argv[0]);
exit(1);
}
const unsigned int shuffle_time = atof(argv[1]);
const char* inputX = argv[2];
const char* inputY = argv[3];
debug_level_set(SILENT);
printf("begin allocating memory:\n");
vec_p x, y;
x = vector_new(4);
y = vector_new(4);
printf("begin read:\n");
vector_read(x, inputX);
vector_read(y, inputY);
// vector_print(x);
double* ret = malloc(sizeof(double)*shuffle_time);
assert(ret);
//////////////////////////////////////////////////////////////////////
// Method 1
// parallel this part
timing_start();
for (int i = 0; i < shuffle_time; i++) {
inplace_shuffle(y->value, y->len);
ret[i] = vector_corr(x,y);
}
timing_stop();
timing_diff();
//////////////////////////////////////////////////////////////////////
// Method 2
timing_start();
vector_corr_permutation(x, y, ret, shuffle_time);
timing_stop();
timing_diff();
//////////////////////////////////////////////////////////////////////
// Method 3
timing_start();
mkl_vector_corr_permutation(x, y, ret, shuffle_time);
timing_stop();
timing_diff();
exit(0);
// output result
printf("Result\n");
for (int i = 0; i < shuffle_time; i++) {
printf("%f\n", ret[i]);
}
vector_delete(&x);
vector_delete(&y);
free(ret);
return 0;
}
