/* machine printing, (write) */
void sexp_pprint(secd_t* secd, cell_t *port, const cell_t *cell) {
switch (cell_type(cell)) {
case CELL_UNDEF: secd_pprintf(secd, port, "#?"); break;
case CELL_INT: secd_pprintf(secd, port, "%d", cell->as.num); break;
case CELL_CHAR:
if (isprint(cell->as.num))
secd_pprintf(secd, port, "#\\%c", (char)cell->as.num);
else
secd_pprintf(secd, port, "#\\x%x", numval(cell));
break;
case CELL_OP: sexp_print_opcode(secd, port, cell->as.op); break;
case CELL_FUNC: secd_pprintf(secd, port, "##func*%p", cell->as.ptr); break;
case CELL_FRAME: secd_pprintf(secd, port,
"##frame@%ld ", cell_index(secd, cell)); break;
case CELL_KONT: secd_pprintf(secd, port,
"##kont@%ld ", cell_index(secd, cell)); break;
case CELL_CONS: sexp_print_list(secd, port, cell); break;
case CELL_ARRAY: sexp_print_array(secd, port, cell); break;
case CELL_STR: secd_pprintf(secd, port, "\"%s\"", strval(cell) + cell->as.str.offset); break;
case CELL_SYM: secd_pprintf(secd, port, "%s", symname(cell)); break;
case CELL_BYTES: sexp_print_bytes(secd, port, strval(cell), mem_size(cell)); break;
case CELL_ERROR: secd_pprintf(secd, port, "#!\"%s\"", errmsg(cell)); break;
case CELL_PORT: sexp_pprint_port(secd, port, cell); break;
case CELL_REF: sexp_pprint(secd, port, cell->as.ref); break;
default: errorf("sexp_print: unknown cell type %d", (int)cell_type(cell));
}
}
size_t mem_alignedsize(void* ptr)
{
uptr_t aligned_addr = (uptr_t)ptr;
uint8 adjust = *((uint8*)(aligned_addr - sizeof(uint8)));
uptr_t raw_addr = aligned_addr - adjust;
return mem_size((void*)raw_addr);
}
static void mem_dump_each_leak(void* that, mapll_t m, int64_t k) {
char* st = (char*)ll2p(mapll_remove(leaks, k));
void* p = ll2p(k);
size_t bytes = mem_size(p);
trace("leak %p allocated %d at: %s", p, bytes, st != null ? st : "???");
free(st); /* IMPORTANT: not mem_free see: mem_alloc code */
}
void* mem_alloc_(size_t size) {
mutex_lock(&mutex);
void* a = malloc(size);
if (a == null && reserved != null) {
trace("MEMORY LOW: allocations=%lld allocated %lld", total_allocations, total_allocated);
memory_low = true;
free(reserved);
reserved = null;
a = malloc(size);
}
if (a != null) {
int allocated = mem_size(a);
const char* st = null;
if (trace_allocs) {
st = stacktrace_(false, null, null, 3);
trace("%p allocated=%d size=%d total: allocations=%lld allocated %lld %s",
a, allocated, size, total_allocations, total_allocated, st);
}
total_allocations++;
total_allocated += allocated;
if (leaks != null) { /* IMPORTANT: intentionally not mem_strdup */
st = st != null ? st : stacktrace_(false, null, null, 3);
mapll_put(leaks, p2ll((void*)a), p2ll((void*)strdup(st)));
}
}
mutex_unlock(&mutex);
return a;
}
/* one instruction per line, nothing else in file, addresses as hex */
memory_t *read_machine_code(FILE *fin, int verbose)
{
memory_t *mem;
int i;
mem = malloc(sizeof(memory_t));
if (mem == NULL)
{
fprintf(stderr, "Memory allocation error\n");
exit(1);
}
mem->size = mem_size(fin);
mem->data = malloc(mem->size * sizeof(int));
if (mem->data == NULL)
{
fprintf(stderr, "Memory allocation error\n");
exit(1);
}
for (i = 0; i < mem->size; i++)
{
fscanf(fin, "%x", mem->data + i);
}
if (verbose)
{
fprintf(stderr, "Read in %d lines\n", mem->size);
}
return mem;
}
int main() {
double size;
void *ptr;
size = mem_size() / (1024 * 1024);
printf("Initial memory use = %.2f MB\n", size);
ptr = safe_malloc(4096 * 1024); // 4 MB?
size = mem_size() / (1024 * 1024);
printf("Memory use after malloc = %.2f MB\n", size);
safe_free(ptr);
size = mem_size() / (1024 * 1024);
printf("Memory use after free = %.2f MB\n", size);
return 0;
}
void* webserver_realloc(void* ptr, size_t s)
{
void* tmp = ALLOC(s, MID_NET);
if (tmp == NULL)
return NULL;
memcpy(tmp, ptr, mem_size(ptr));
FREE(ptr);
return tmp;
}
char *get_string(int smo)
{
//get_string: gets a string from a Shared Memory Object
int size = mem_size(smo);
char *tmp = (char *)malloc(size);
if(read_mem(smo, 0, size, tmp))
{
return NULL;
}
return tmp;
}
void
list_remove (LIST *list, void *data, size_t size)
{
LIST
*node;
ASSERT (!list_empty (list));
node = list-> next;
ASSERT (mem_size (node) - sizeof (LIST) == size);
memcpy ((char *) data, (char *) node + sizeof (LIST), size);
list_unlink (node);
mem_free (node);
}
void mem_free_(const void* a) {
if (a != null) {
size_t allocated = mem_size(a);
if (trace_allocs) {
trace("%p allocated=%d total: allocations=%lld allocated %lld", a, allocated, total_allocations, total_allocated);
}
mutex_lock(&mutex);
total_allocations--;
total_allocated -= allocated;
if (leaks != null) {
mapll_remove(leaks, p2ll((void*)a));
}
mutex_unlock(&mutex);
free((void*)a);
}
}
void CServer::server_stat_request()
{
send_string("FSearch server build on " __DATE__ " " __TIME__);
send_string("FSearch server version " VERSION);
send_string_fmt("Active clients: %u", m_clients.size());
send_string_fmt("Debug level: %d", logger->get_level());
send_string_fmt("Allocated in swap: %u Mb", swapAllocator->allocated()/(1024*1024));
send_string_fmt("Total swap space used: %u Mb", swapAllocator->memUsed()/(1024*1024));
send_string_fmt("Total hosts: %u", m_host_set.host_count());
send_string_fmt("Total files: %u", m_host_set.file_count());
send_string_fmt("Total files size: %d Gb", m_host_set.total_size()/(1024*1024*1024));
if (m_host_set.host_count() > 0) {
send_string_fmt("Average files per host: %d", m_host_set.file_count()/m_host_set.host_count());
}
if (m_host_set.file_count() > 0) {
send_string_fmt("Average file size: %d", m_host_set.total_size()/m_host_set.file_count());
}
send_string_fmt("Total server memory usage: %u Mb", mem_size()/(1024*1024));
send_string_fmt("Number of swap pages: %u Mb", page_max*page_size/(1024*1024));
send_string_fmt("Present swap pages: %u Mb", page_present*page_size/(1024*1024));
send_string_fmt("Locked swap pages: %u Mb", page_locked*page_size/(1024*1024));
send_string_fmt("Number of page loads: %lu", page_read_count);
send_string_fmt("Number of page swaps: %lu", page_swap_count);
send_string_fmt("Total queries: %u", m_cache.total());
send_string_fmt("Total uncached queries: %u", m_cache.query_made());
send_string_fmt("Average query time: %.3lf sec", m_cache.avg_search_time());
send_string_fmt("Maximal query time: %.3lf sec", m_cache.max_search_time());
send_string_fmt("Queries in cache: %u", m_cache.count());
send_string_fmt("Query cache size: %u Kb", m_cache.mem_size()/1024);
send_string_fmt("Query cache hits: %u", m_cache.hits());
if (m_cache.total() > 0) {
send_string_fmt("Query cache hit ratio: %5.2lf%%", 100.0*m_cache.hits()/m_cache.total());
send_string_fmt("Average query matches: %d", m_cache.total_matched()/m_cache.total());
}
send_string_fmt("Word hash size: %u", wordhash.size());
send_string_fmt("Dictionary index size: %u Kb", wordhash.get_dictindex().mem_size()/1024);
send_string_fmt("Max collisions: %u", wordhash.max_collisions());
send_string_fmt("Total words: %u", wordhash.total_words());
send_string_fmt("Common words: %u", wordhash.common_count());
send_string("END");
}
static void output(ErlDrvData handle, char *buf, int len) {
bloom_drv_t *driver = (bloom_drv_t *)handle;
char command = buf[0];
switch (command) {
case SETUP:
setup(driver, &buf[1], len-1);
break;
case PUT:
put(driver, &buf[1], len-1);
break;
case HAS:
has(driver, &buf[1], len-1);
break;
case MEM_SIZE:
mem_size(driver);
break;
case KEY_SIZE:
key_size(driver);
break;
}
}
static void print_results(smt_core_t *core, double construction_time, double search_time) {
dpll_stats_t *stat;
double mem_used, simplified_percent;
stat = &core->stats;
show_stats(stat);
printf("Search time : %.4f s\n", search_time);
mem_used = mem_size() / (1024 * 1024);
if (mem_used > 0) {
printf("Memory used : %.2f MB\n", mem_used);
}
printf("\n\n");
// Print status again, in format used by Leonardo's scripts
print_status(stdout, smt_status(core));
printf("\n");
validate_assignment(core);
printf("\n");
simplified_percent = 0.0;
if (stat->literals_before_simpl > 0) {
simplified_percent = (100.0 * stat->subsumed_literals) / stat->literals_before_simpl;
}
printf("STAT %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu32" %"PRIu64" %"PRIu64" %.2f %.2f %.2f\n",
stat->decisions,
stat->conflicts,
stat->propagations,
stat->restarts,
stat->literals_before_simpl,
stat->learned_literals,
mem_used,
(search_time + construction_time),
simplified_percent);
fflush(stdout);
}
int main(int argc, char *argv[]) {
uint32_t i, j, n;
double runtime, memused;
int32_t x, *val;
if (argc != 2) {
fprintf(stderr, "Usage: %s filename\n", argv[0]);
fprintf(stderr, " filename must contain a set of strings, one per line, less than 100 char long\n");
fflush(stderr);
exit(1);
}
words_from_file(argv[1]);
init_stbl(&sym_table, 0);
val = (int32_t *) malloc(n_words * sizeof(int32_t));
if (val == NULL) {
fprintf(stderr, "Failed to allocate array val\n");
exit(1);
}
for (i=0; i<n_words; i++) {
x = stbl_find(&sym_table, words[i]);
if (x < 0) {
stbl_add(&sym_table, words[i], i);
val[i] = i;
} else {
val[i] = x;
}
}
printf("\n--- checking ---\n");
for (i=0; i<n_words; i++) {
x = stbl_find(&sym_table, words[i]);
if (x != val[i]) {
printf("*** Error: %s, val = %"PRId32", should be %"PRId32" ***\n", words[i], x, val[i]);
fflush(stdout);
exit(1);
}
}
printf("\n*** Added %"PRIu32" words from %s ***\n", n_words, argv[1]);
// repeated additions of the same symbols with multiple lookups
// warning: this code does not work (may give a false alarm)
// if the input file contains duplicates.
n = (n_words < 200) ? n_words : 200;
printf("\n*** Repeated symbol addition ***\n");
runtime = get_cpu_time();
for (i=0; i<10000; i++) {
for (j=0; j<n; j++) {
stbl_add(&sym_table, words[j], new_val(i, j));
}
for (j=0; j<n; j++) {
x = stbl_find(&sym_table, words[j]);
if (x != new_val(i, j)) {
printf("*** Error: %s, val = %"PRId32", should be %"PRId32" ***\n", words[j], x, new_val(i, j));
fflush(stdout);
exit(1);
}
}
for (j=0; j<n; j++) {
x = stbl_find(&sym_table, words[j]);
if (x != new_val(i, j)) {
printf("*** Error: %s, val = %"PRId32", should be %"PRId32" ***\n", words[j], x, new_val(i, j));
fflush(stdout);
exit(1);
}
}
for (j=0; j<n_words; j++) {
x = stbl_find(&sym_table, words[j]);
}
for (j=0; j<n; j++) {
x = stbl_find(&sym_table, words[j]);
if (x != new_val(i, j)) {
printf("*** Error: %s, val = %"PRId32", should be %"PRId32" ***\n", words[j], x, new_val(i, j));
fflush(stdout);
exit(1);
}
}
for (j=0; j<n_words; j++) {
x = stbl_find(&sym_table, words[j]);
}
}
runtime = get_cpu_time() - runtime;
memused = mem_size() / (1024 * 1024);
printf("Adding 10000 times the same %"PRIu32" words + repeated lookups\n", n);
printf("Runtime: %.4f s\n", runtime);
printf("Table size: %"PRIu32" (nelems = %"PRIu32", ndeleted = %"PRIu32")\n",
sym_table.size, sym_table.nelems, sym_table.ndeleted);
if (memused > 0) {
printf("Memory used: %.2f MB\n", memused);
}
clear_words();
free(val);
delete_stbl(&sym_table);
return 0;
}
void cmd_create_task(struct pm_msg_create_task *msg, struct pm_task *ctask)
{
struct pm_task *tsk = NULL;
UINT16 new_task_id = msg->new_task_id;
UINT16 flags = msg->flags;
UINT16 type = (flags & SERVER_TASK) / SERVER_TASK;
UINT32 psize, ret;
char *path = NULL;
if(pman_stage == PMAN_STAGE_INITIALIZING)
{
cmd_inform_result(msg, ctask->id, PM_IS_INITIALIZING, 0, 0);
return;
}
if(new_task_id != 0xFFFF)
{
if (tsk_lower_bound[type] <= new_task_id && new_task_id <= tsk_upper_bound[type])
{
tsk = tsk_get(new_task_id);
if(tsk != NULL)
{
/* new_task_id is not free to be used */
cmd_inform_result(msg, ctask->id, PM_TASK_ID_TAKEN, 0, 0);
return;
}
}
else
{
/* new_task_id is out of range */
cmd_inform_result(msg, ctask->id, PM_TASK_ID_INVALID, 0, 0);
return;
}
}
else
{
/* search for a free task id */
new_task_id = tsk_get_id(tsk_lower_bound[type], tsk_upper_bound[type]);
if(new_task_id == 0xFFFF)
{
cmd_inform_result(msg, ctask->id, PM_NO_FREE_ID, 0, 0);
return;
}
}
tsk = tsk_create(new_task_id);
if(tsk == NULL)
{
cmd_inform_result(msg, ctask->id, PM_NOT_ENOUGH_MEM, 0, 0);
return;
}
path = NULL;
psize = mem_size(msg->path_smo_id);
if(psize < 1)
{
tsk_destroy(tsk);
cmd_inform_result(msg, ctask->id, PM_BAD_SMO, 0, 0);
return;
}
path = kmalloc(psize);
if(path == NULL)
{
tsk_destroy(tsk);
cmd_inform_result(msg, ctask->id, PM_NOT_ENOUGH_MEM, 0, 0);
return;
}
/* Read Path */
if(read_mem(msg->path_smo_id, 0, psize, path) != SUCCESS)
{
tsk_destroy(tsk);
cmd_inform_result(msg, ctask->id, PM_BAD_SMO, 0, 0);
return;
}
tsk->flags = (flags & SERVER_TASK)? TSK_FLAG_SERVICE : 0;
if(path[psize-1] == '\0') psize--;
tsk->creator_task = ctask->id;
tsk->creator_task_port = msg->response_port;
tsk->command_inf.command_req_id = msg->req_id;
tsk->command_inf.command_ret_port = -1;
tsk->command_inf.command_sender_id = -1;
ret = loader_create_task(tsk, path, psize, msg->param, type, LOADER_CTASK_TYPE_PRG);
if(ret != PM_OK)
{
tsk_destroy(tsk);
kfree(path);
cmd_inform_result(msg, ctask->id, ret, 0, 0);
}
}
void cmd_load_library(struct pm_msg_loadlib *msg, UINT16 loader_task)
{
struct pm_task *tsk;
UINT32 psize;
char *path = NULL;
if(pman_stage == PMAN_STAGE_INITIALIZING)
{
pman_print_dbg("PM LOAD LIB ERR1\n");
cmd_inform_result(msg, loader_task, PM_IS_INITIALIZING, 0, 0);
return;
}
if(msg->vlow < PMAN_MAPPING_BASE || msg->vhigh < msg->vlow)
{
pman_print_dbg("PM LOAD LIB ERR2\n");
cmd_inform_result(msg, loader_task, PM_INVALID_BOUNDARIES, 0, 0);
return;
}
tsk = tsk_get(loader_task);
if(tsk->flags & TSK_LOADING_LIB)
{
cmd_inform_result(msg, loader_task, PM_TASK_RETRY_LATER, 0, 0);
return;
}
if(!(tsk->flags & TSK_DYNAMIC))
{
cmd_inform_result(msg, loader_task, PM_ERROR, 0, 0);
return;
}
path = NULL;
psize = mem_size(msg->path_smo_id);
pman_print_dbg("LOADING LIB path size %i\n", psize);
if(psize < 1)
{
cmd_inform_result(msg, loader_task, PM_BAD_SMO, 0, 0);
return;
}
path = kmalloc(psize);
if(path == NULL)
{
cmd_inform_result(msg, loader_task, PM_NOT_ENOUGH_MEM, 0, 0);
return;
}
/* Read Path */
if(read_mem(msg->path_smo_id, 0, psize, path) != SUCCESS)
{
kfree(path);
cmd_inform_result(msg, loader_task, PM_BAD_SMO, 0, 0);
return;
}
pman_print_dbg("LOADING LIB path %s\n", path);
tsk->command_inf.callback = cmd_finished__callback;
tsk->command_inf.command_ret_port = msg->response_port;
tsk->command_inf.command_req_id = msg->req_id;
tsk->command_inf.command_sender_id = loader_task;
tsk->flags |= TSK_LOADING_LIB;
// load the library
int ret = vmm_lib_load(tsk, path, psize, msg->vlow, msg->vhigh);
if(!ret)
{
kfree(path);
cmd_inform_result(msg, loader_task, PM_ERROR, 0, 0);
}
else if(ret == 2)
{
kfree(path);
cmd_inform_result(msg, loader_task, PM_OK, 0, 0);
return;
}
}
int main(int argc, char *argv[]) {
char *filename;
int32_t code;
FILE *dump;
double time, mem_used;
if (argc > 2) {
fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
exit(YICES_EXIT_USAGE);
}
if (argc == 2) {
// read from file
filename = argv[1];
if (init_smt_file_lexer(&lexer, filename) < 0) {
perror(filename);
exit(YICES_EXIT_FILE_NOT_FOUND);
}
} else {
// read from stdin
init_smt_stdin_lexer(&lexer);
}
yices_init();
init_smt_tstack(&stack);
init_parser(&parser, &lexer, &stack);
init_benchmark(&bench);
code = parse_smt_benchmark(&parser, &bench);
if (code == 0) {
printf("No syntax error found\n");
}
if (benchmark_reduced_to_false(&bench)) {
printf("Reduced to false\n\nunsat\n");
fflush(stdout);
}
printf("\n");
time = get_cpu_time();
mem_used = mem_size() / (1024 * 1024);
printf("Construction time: %.4f s\n", time);
printf("Memory used: %.2f MB\n\n", mem_used);
fflush(stdout);
dump = fopen("yices2new.dmp", "w");
if (dump == NULL) {
perror("yices2new.dmp");
} else {
dump_benchmark(dump, &bench);
fclose(dump);
}
delete_benchmark(&bench);
delete_parser(&parser);
close_lexer(&lexer);
delete_tstack(&stack);
yices_exit();
return YICES_EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
char *filename;
int32_t code;
double time, mem_used;
if (argc > 2) {
fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
exit(YICES_EXIT_USAGE);
}
if (argc == 2) {
// read from file
interactive = false;
filename = argv[1];
if (init_smt2_file_lexer(&lexer, filename) < 0) {
perror(filename);
exit(YICES_EXIT_FILE_NOT_FOUND);
}
} else {
// read from stdin
interactive = true;
init_smt2_stdin_lexer(&lexer);
}
yices_init();
init_smt2(true, 0, interactive);
init_smt2_tstack(&stack);
init_parser(&parser, &lexer, &stack);
// disable SMT2_CHECK_SAT/PUSH/POP/GET_VALUE
tstack_add_op(&stack, SMT2_CHECK_SAT, false, eval_smt2_skip, check_smt2_skip);
tstack_add_op(&stack, SMT2_PUSH, false, eval_smt2_skip, check_smt2_skip);
tstack_add_op(&stack, SMT2_POP, false, eval_smt2_skip, check_smt2_skip);
tstack_add_op(&stack, SMT2_GET_VALUE, false, eval_smt2_skip, check_smt2_skip);
// smt2_set_verbosity(100);
while (smt2_active()) {
if (interactive) {
fputs("smt2> ", stdout);
fflush(stdout);
}
code = parse_smt2_command(&parser);
if (code < 0) {
// syntax error
if (interactive) {
flush_lexer(&lexer);
} else {
break; // exit
}
}
fflush(stdout);
}
// statistics
time = get_cpu_time();
mem_used = mem_size() / (1024 * 1024);
printf("\nRun time: %.4f s\n", time);
printf("Memory used: %.2f MB\n\n", mem_used);
fflush(stdout);
delete_parser(&parser);
close_lexer(&lexer);
delete_tstack(&stack);
delete_smt2();
yices_exit();
return YICES_EXIT_SUCCESS;
}
static void *fb(void) { return malloc(mem_size()); }
int main(int argc, char *argv[]) {
bool interactive;
int32_t code;
FILE *dump;
double memused;
process_command_line(argc, argv);
yices_init();
init_tstack(&stack, NUM_BASE_OPCODES);
interactive = false;
if (input_filename == NULL) {
init_yices_stdin_lexer(&lexer);
interactive = true;
} else {
if (init_yices_file_lexer(&lexer, input_filename) < 0) {
perror(input_filename);
exit(YICES_EXIT_FILE_NOT_FOUND);
}
}
init_parser(&parser, &lexer, &stack);
while (current_token(&lexer) != TK_EOS) {
if (interactive) {
printf("yices> ");
fflush(stdout);
}
code = parse_yices_command(&parser, stderr);
if (code < 0) {
flush_lexer(&lexer);
}
}
delete_parser(&parser);
close_lexer(&lexer);
delete_tstack(&stack);
memused = mem_size() / (1024 * 1024);
if (memused > 0) {
fprintf(stderr, "Memory used: %.2f MB\n", memused);
}
if (dump_requested) {
if (dump_filename == NULL) {
dump = stdout;
} else {
dump = fopen(dump_filename, "w");
if (dump == NULL) {
perror(dump_filename);
exit(YICES_EXIT_FILE_NOT_FOUND);
}
}
fprintf(dump, "\n==== ALL TYPES ====\n");
print_type_table(dump, __yices_globals.types);
fflush(dump);
fprintf(dump, "\n==== ALL TERMS ====\n");
print_term_table(dump, __yices_globals.terms);
fflush(dump);
if (dump_filename != NULL) {
if (fclose(dump) != 0) {
fprintf(stderr, "Error while closing dump file: ");
perror(dump_filename);
}
}
}
yices_exit();
return 0;
}
