Mercurial > repos > rhope
view interp.c @ 17:d05184970c1c
Merged accidentally created head
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 26 May 2009 23:37:59 -0400 |
parents | 23dd9c766699 |
children | 20d40cb8abf3 |
line wrap: on
line source
#ifdef WIN32 #include <windows.h> #include <winsock.h> #include <crtdbg.h> #else #ifdef SYLLABLE #include <unistd.h> #include <atheos/threads.h> #else #ifdef NINTENDO_DS #include <nds.h> #else #include <unistd.h> #include <pthread.h> #endif #endif #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include "mt19937ar.h" #include "interp.h" #include "vis_threading.h" #include "datum.h" #include "parser.h" #include "saveload.h" #ifdef TEXT_FILE_DEBUG FILE * debugfile; #endif char debugbuffer[1024]; //extern HWND hWnd; extern char new_name_buf[256]; extern int buf_size; int lock_fail_counter; int lock_counter; VIS_CRITICAL_SECTION(data_lock) VIS_CRITICAL_SECTION(worker_queue_lock) VIS_CRITICAL_SECTION(randlock) VIS_Event(queue_add_event) int program_count=1; VIS_CRITICAL_SECTION(program_count_lock) //#define ENABLE_PROFILING 1 #ifdef ENABLE_PROFILING __int64 vis_profile_start_times[NUM_PROFS]; __int64 vis_profile_running_total[NUM_PROFS]; int vis_profile_counts[NUM_PROFS]; __declspec(naked) unsigned __int64 __cdecl rdtsc(void) { __asm { rdtsc ret ; return value at EDX:EAX } } #define PROF_INIT_CUSTOM 0 #define PROF_WORKER_THREAD 1 #define PROF_PROCESS_WORKER 2 #define PROF_CLEANUP_CUSTOM 3 #define PROF_SUB_CALLBACK 4 #define PROF_CLEANUP_RELEASE_REFS 5 #define PROF_CLEANUP_CHECK 6 #define PROF_CLEANUP_FREELISTS 7 #define PROF_PROCESS_OUTPUTS 8 #define PROF_OPT_PREP_INPUT 9 #define PROF_RUN_OPT 10 #define PROF_ADDQUEUE 11 #define PROF_ADDQUEUE_MALLOC 12 #define PROF_OPT_LOOP 13 #define PROF_EXECUTE_WORKER 14 #define PROF_EXECUTE_OTHER 15 #define PROF_PREP_MAGIC 16 #define PROF_CONVERT_INPUTS 17 #define PROF_EXECUTE_CUSTOM 18 #define PROF_EXECUTE_BUILTIN 19 #define PROF_EMPTYFUNC 20 #define PROF_NOCODE 21 #define PROF_LESSERWHOLE 22 #define PROF_EQUALWHOLE 23 #define PROF_PARTIAL_EXEC 24 #define PROF_ADDWHOLE 25 #define PROF_FULL_EXEC 26 #define PROF_OPT_EXEC_USER 27 #define PROF_OPT_EXEC_BUILT 28 #define PROF_VIRTUAL_DECODE 27 #define PROF_VIRTUAL_EXECUTE 28 /*#define VIS_PROFILE_START(index) vis_profile_start_times[index] = rdtsc() #define VIS_PROFILE_END(index) vis_profile_running_total[index] += (rdtsc()-vis_profile_start_times[index]); ++vis_profile_counts[index] #else #define VIS_PROFILE_START(index) #define VIS_PROFILE_END(index)*/ #endif queue_entry * worker_queue; queue_section first_section; queue_section * current_section; int queue_start; int queue_len; BOOL execute_active=FALSE; char text_buf[256]; int text_buf_size; VIS_CRITICAL_SECTION(text_buf_lock) #ifdef WIN32 WSADATA wsa_data; #ifdef GUI_LIB char errorbuffer[1024]; #endif #endif worker_instance * main_instance; //company companylist[40]; //int num_companies=0; datum * global_store_dict; VIS_CRITICAL_SECTION(global_store_lock); int empty_func(datum ** a, queue_entry * worker_entry) { return 0; } worker_impl empty_test = empty_func; /* void set_in_child(worker_def * parent, int worker_num, BOOL * in_child, BOOL value, int exclude_worker) { int j,i = parent->workerlist[worker_num].wire_down_lookup; if(exclude_worker >= 0 && exclude_worker == worker_num) return; in_child[worker_num] = value; while(parent->wirelist[j=parent->workers_to_wires_down[i]].start_worker == worker_num && j >= 0) set_in_child(parent, parent->wirelist[j].end_worker, in_child, value); } void build_child_worker(worker_def * parent, int worker_num, int output_num) { int i,j, num_child_workers, num_child_wires, child_def; BOOL * in_child = malloc(sizeof(BOOL)* parent->num_workers); int * child_offsets = malloc(sizeof(int) * parent->num_workers); for(i = 0; i < parent->num_workers; ++i) { in_child[i] = FALSE; child_offsets[i] = -1; } i = parent->workerlist[worker_num].wire_down_lookup; while(parent->wirelist[j=parent->workers_to_wires_down[i]].start_worker == worker_num && j >= 0) { if(parent->wirelist[j].output_num == output_num) set_in_child(parent, parent->wirelist[j].end_worker, in_child, TRUE,-1); } i = parent->workerlist[worker_num].wire_down_lookup; while(parent->wirelist[j=parent->workers_to_wires_down[i]].start_worker == worker_num && j >= 0) { if(parent->wirelist[j].output_num != output_num) set_in_child(parent, parent->wirelist[j].end_worker, in_child, FALSE,-1); } for(i = 0; i < parent->num_workers; ++i) { if(i != worker_num && (parent->workerlist[i].type == 4 || (parent->workerlist[i].type == 2 && !in_child[i]))) set_in_child(parent, i, in_child, FALSE); } for(i = 0; i < parent->num_workers; ++i) { if(in_child[i]) child_offests[i] = num_child_workers++; } for(i = 0; i < parent->num_wires; ++i) { if(in_child[parent->wirelist[i].start_worker] || in_child[parent->wirelist[i].end_worker]) ++num_child_wires; } child_def = num_defs++;//needs lock or atomic incrememnt deflist[child_def].workerlist = malloc(sizeof(worker)*num_child_workers); deflist[child_def].wirelist = malloc(sizeof(wire)*num_child_wires); for(i = 0; i < parent->num_workers; ++i) { if(in_child[i]) deflist[child_def].workerlist[child_offests[i]] = parent->workerlist[i]; } } */ #define MAX_TRACE_DEPTH 40 void print_stack_trace(worker_instance * stack_instance) { int i = 0; ERRORPUTS("Stack trace:\n"); while(stack_instance && i < MAX_TRACE_DEPTH) { ERRORPRINTF("%s\n", stack_instance->def->name); stack_instance = stack_instance->caller_instance; ++i; } if(stack_instance) { ERRORPUTS("Stack trace aborted after 40 entries\n"); } } void check_tail(worker_def * def) { custom_worker * worker = def->implement_func; int i,j,k,endworker; BOOL can_tail, outputs_handled[32]; for(i = 0; i < worker->num_workers; ++i) { if(worker->workerlist[i].type == WORKER) { can_tail = TRUE; for(j = 0; j < def->num_outputs; ++j) outputs_handled[j] = FALSE; j = worker->workerlist[i].wire_down_lookup; while((k=worker->workers_to_wires_down[j]) >= 0 && worker->wirelist[k].start_worker == i) { endworker = worker->wirelist[k].end_worker; if(worker->workerlist[endworker].type != OUTPUT || worker->workerlist[endworker].io_num != worker->wirelist[k].output_num) { can_tail = FALSE; break; } else outputs_handled[worker->wirelist[k].output_num] = TRUE; ++j; } if(can_tail) { for(j = 0; j < def->num_outputs; ++j) if(!outputs_handled[j]) { can_tail = FALSE; break; } if(can_tail) if(worker->workerlist[i].value_index == def) worker->workerlist[i].type = TAIL_RECURSE; else if(!def->num_stores) worker->workerlist[i].type = TAIL_CALL; } } } } BOOL method_match(char * name, char * method_name) { int i = 0; while(name[i] != '\0' && method_name[i] != '@' && method_name[i] != '\0') { if(name[i] != method_name[i]) return FALSE; ++i; } if(name[i] != '\0' || method_name[i] != '@') return FALSE; return TRUE; } worker_def * find_method(int type, char * name, int num_inputs, program * prog) { int i; worker_def * output = NULL; company * companylist = prog->companylist; VIS_EnterCriticalSection(companylist[type].lock); for(i = 0; i < companylist[type].num_methods; ++i) { //DEBUGPRINTF( "Checking method %s(%d,%d)\n", companylist[type].methodlist[i]->name, companylist[type].methodlist[i]->num_inputs, companylist[type].methodlist[i]->num_outputs); if(companylist[type].methodlist[i]->num_inputs == num_inputs && method_match(name, companylist[type].methodlist[i]->name)) { DEBUGPRINTF( "Found method: %s\n", companylist[type].methodlist[i]->name); output = companylist[type].methodlist[i]; break; } } VIS_LeaveCriticalSection(companylist[type].lock); return output; } worker_def * find_method_noinputcheck(int type, char * name, program * prog) { int i; worker_def * output = NULL; company * companylist = prog->companylist; VIS_EnterCriticalSection(companylist[type].lock); for(i = 0; i < companylist[type].num_methods; ++i) { //DEBUGPRINTF( "Checking method %s(%d,%d)\n", companylist[type].methodlist[i]->name, companylist[type].methodlist[i]->num_inputs, companylist[type].methodlist[i]->num_outputs); if(method_match(name, companylist[type].methodlist[i]->name)) { DEBUGPRINTF( "Found method: %s\n", companylist[type].methodlist[i]->name); output = companylist[type].methodlist[i]; break; } } VIS_LeaveCriticalSection(companylist[type].lock); return output; } worker_def * find_converter_method(int totype, int fromtype, program * prog) { int i; company * companylist = prog->companylist; DEBUGPRINTF( "Finding converter from %s to %s\n", companylist[fromtype].name, companylist[totype].name); //DEBUGPRINTF( "Num methods %d\n", companylist[totype].num_methods); for(i = 0; i < companylist[totype].num_methods; ++i) { //DEBUGPRINTF("methodlist[i]: %X\n", companylist[totype].methodlist[i]); DEBUGPRINTF( "Checking method %s\n", companylist[totype].methodlist[i]->name); if(companylist[totype].methodlist[i]->name[0] == '<' && method_match(companylist[fromtype].name, companylist[totype].methodlist[i]->name+1)) { DEBUGPRINTF( "Found Method %s\n", companylist[totype].methodlist[i]->name); return companylist[totype].methodlist[i]; } } return NULL; } worker_instance * init_custom_worker_type(int aworker, worker_instance * caller, worker_def * def, instance_callback callback, void * callback_data, datum ** params, int type) { int i, workerlist_size, j, add_index_count=0; int add_index[32]; datum * work_params[32]; datum * temp_params[3]; global_store * store; worker_instance * instance; BOOL release_params = TRUE; def_make_lookup(def); workerlist_size = sizeof(worker_instance_data)*(def->implement_func->num_workers); //DEBUGPRINTF("workerlist_size: %d * %d = %d, wirelist_size: %d * %d = %d.\n", sizeof(worker_instance_data), def->implement_func->num_workers, workerlist_size, sizeof(wire_instance_data), def->implement_func->num_wires, sizeof(wire_instance_data)*(def->implement_func->num_wires)); //DEBUGPRINTF("Before malloc(%d)\n",sizeof(worker_instance) + workerlist_size + sizeof(wire_instance_data)*(def->implement_func->num_wires)); if(type == TAIL_RECURSE || type == TAIL_CALL) { VIS_EnterCriticalSection(caller->counter_lock); if(caller->in_progress_count <= 1 && !caller->in_queue_count) { VIS_LeaveCriticalSection(caller->counter_lock); instance = caller; for(i = 0; i < instance->num_workers; ++i) { if(instance->def->implement_func->workerlist[i].type != WORKER && instance->def->implement_func->workerlist[i].type != TAIL_RECURSE && instance->def->implement_func->workerlist[i].type != TAIL_CALL && instance->workerlist[i].value) release_ref(instance->workerlist[i].value); if(instance->workerlist[i].ready_count && instance->workerlist[i].ready_count < (instance->def->implement_func->workerlist[i].num_inputs + (instance->def->implement_func->workerlist[i].null_input ? 1 : 0))) { DEBUGPRINTF("Freeing params for worker number %d, ready_count: %d, num_inputs: %d, null_input: %d, instance: %X\n", i, instance->workerlist[i].ready_count,instance->def->implement_func->workerlist[i].num_inputs, instance->def->implement_func->workerlist[i].null_input, instance); for(j = 0; j <= instance->def->implement_func->workerlist[i].num_inputs; ++j) { DEBUGPRINTF("Releasing param %d of worker %d\n", j, i); release_ref(instance->workerlist[i].params[j]); } } } for(i = 0; i < def->num_inputs; ++i) work_params[i] = params[i]; params = work_params; if(type == TAIL_RECURSE) { instance->in_progress_count = 0; //TODO: adjust profile counter? goto init_workerlist; } else { aworker = instance->worker_in_caller; callback = instance->callback; callback_data = instance->callback_data; caller = instance->caller_instance; VIS_DeleteCriticalSection(instance->counter_lock); free(instance); } } else { VIS_LeaveCriticalSection(caller->counter_lock); } } instance = MALLOC(sizeof(worker_instance) + workerlist_size/* + sizeof(wire_instance_data)*(def->implement_func->num_wires) */,"instance"); //DEBUGPRINTF("malloc returned %X.\n", instance); VIS_PROFILE_START(PROF_INIT_CUSTOM); //DEBUGPRINTF("init_custom_worker, instance: %X\n", instance); #ifdef USER_PROFILE QueryPerformanceCounter(&(instance->start)); #endif instance->def = def; instance->num_workers = def->implement_func->num_workers; instance->workerlist = (worker_instance_data *)(((char *)instance) + sizeof(worker_instance));//malloc(sizeof(worker_instance_data)*(def->implement_func->num_workers)); //DEBUGPRINTF("workerlist at %X\n", instance->workerlist); /*instance->num_wires = def->implement_func->num_wires; instance->wirelist = (wire_instance_data *)(((char *)(instance->workerlist)) + workerlist_size);//malloc(sizeof(wire_instance_data)*(def->implement_func->num_wires)); DEBUGPRINTF("wirelist at %X\n", instance->wirelist);*/ instance->callback = callback; instance->worker_in_caller = aworker; instance->callback_data = callback_data; instance->caller_instance = caller; VIS_InitializeCriticalSection(instance->counter_lock); instance->in_progress_count = 0; instance->in_queue_count = 0; if(def->num_stores) { instance->trans = MALLOC(sizeof(transaction) + sizeof(global_store_use) *(def->num_stores - 1),"transaction"); VIS_EnterCriticalSection(global_store_lock); for(i = 0; i < def->num_stores; ++i) { temp_params[0] = add_ref(global_store_dict); temp_params[1] = make_string(def->uses_stores[i], -1, def->program); vis_dict_index(temp_params, NULL); if(!temp_params[0]) { printf("Error: Global store %s is not initialized\n", def->uses_stores[i]); DEBUGPRINTF("Error: Global store %s is not initialized\n", def->uses_stores[i]); VIS_LeaveCriticalSection(global_store_lock); return NULL; } instance->trans->stores[i].store = temp_params[0]->c.generic.data; instance->trans->stores[i].instance_data = instance->trans->stores[i].begin_data = add_ref(instance->trans->stores[i].store->data); VIS_InitializeCriticalSection(instance->trans->stores[i].lock); //Is this really necessary? release_ref(temp_params[0]); } VIS_LeaveCriticalSection(global_store_lock); instance->trans->num_stores = def->num_stores; if((def->transaction_flags & TRANSACTION_WRITE) && (def->transaction_flags & TRANSACTION_TYPE_MASK) == TRANSACTION_RETRY) { release_params = FALSE; for(i = 0; i < def->num_inputs; ++i) instance->trans->params[i] = params[i]; } } else { instance->trans = NULL; } init_workerlist: //DEBUGPUTS("init worker values\n"); for(i = 0; i < instance->num_workers; ++i) { // DEBUGPRINTF("InitializeCriticalSection on workerlist[%d].worker_lock (%X)\n", i, &(instance->workerlist[i].worker_lock)); VIS_InitializeCriticalSection(instance->workerlist[i].worker_lock); //DEBUGPUTS("ready_count = 0\n"); instance->workerlist[i].ready_count = 0; if(def->implement_func->workerlist[i].type == INPUT && params) instance->workerlist[i].value = add_ref(params[def->implement_func->workerlist[i].io_num]); else //if(def->implement_func->workerlist[i].type != 2) instance->workerlist[i].value = NULL; //DEBUGPRINTF("instance->workerlist[%d].value = %X\n", i, instance->workerlist[i].value); for(j = 0; j <= def->implement_func->workerlist[i].num_inputs; ++j) instance->workerlist[i].params[j] = NULL; //DEBUGPRINTF("num_inputs: %d, null_input: %d\n", def->implement_func->workerlist[i].num_inputs, def->implement_func->workerlist[i].null_input); //There's still a potential race condition here, but it's unlikely to occur except on a system with an insane number of cores/processors //and only on custom workers that have more than 32 items that will be initially ready if(!def->implement_func->workerlist[i].num_inputs && !def->implement_func->workerlist[i].null_input) { DEBUGPRINTF("adding worker %s(%d) to queue\n", def->implement_func->workerlist[i].name, i); add_index[add_index_count++] = i; if(add_index_count == 32) { add_multiple(add_index, add_index_count, instance); add_index_count = 0; } //add_queue(i,instance); } } if(params) { if(release_params) { //DEBUGPUTS("release params\n"); for(i = 0; i < def->num_inputs; ++i) release_ref(params[i]); } } if(add_index_count > 0) add_multiple(add_index, add_index_count, instance); VIS_PROFILE_END(PROF_INIT_CUSTOM); return instance; } worker_instance * init_custom_worker(int aworker, worker_instance * caller, worker_def * def, instance_callback callback, void * callback_data, datum ** params) { return init_custom_worker_type(aworker, caller, def, callback, callback_data, params, WORKER); } void cleanup_check(queue_entry aworker) { char msg[256]; VIS_EnterCriticalSection(aworker.instance->counter_lock); --(aworker.instance->in_progress_count); DEBUGPRINTF( "Cleanup Check on %s<%d>:%X, in_progress: %d, in_queue: %d\n", aworker.instance->def->name, aworker.instance->worker_in_caller, aworker.instance, aworker.instance->in_progress_count,aworker.instance->in_queue_count); if(aworker.instance->in_progress_count == 0 && aworker.instance->in_queue_count == 0) { VIS_LeaveCriticalSection(aworker.instance->counter_lock); cleanup_custom_worker(aworker.instance, aworker.worker_num); } else { VIS_LeaveCriticalSection(aworker.instance->counter_lock); } } void cleanup_custom_worker(worker_instance * instance, int worker_num) { BOOL do_commit = TRUE; int i,j; queue_entry incaller; global_store * store; #ifdef USER_PROFILE LARGE_INTEGER end; LARGE_INTEGER duration; #endif if(instance->trans) { if(instance->def->transaction_flags & TRANSACTION_WRITE) { VIS_EnterCriticalSection(global_store_lock); if((instance->def->transaction_flags & TRANSACTION_TYPE_MASK) != TRANSACTION_FORCE) { for(i = 0; i < instance->trans->num_stores; ++i) { if(instance->trans->stores[i].begin_data != instance->trans->stores[i].store->data) { do_commit = FALSE; break; } } } if(do_commit) { for(i = 0; i < instance->trans->num_stores; ++i) { release_ref(instance->trans->stores[i].store->data); instance->trans->stores[i].store->data = instance->trans->stores[i].instance_data; } } VIS_LeaveCriticalSection(global_store_lock); if(!do_commit)//retry transaction { for(i = 0; i < instance->trans->num_stores; ++i) release_ref(instance->trans->stores[i].instance_data); puts("retrying transaction"); init_custom_worker(instance->worker_in_caller, instance->caller_instance, instance->def, instance->callback, instance->callback_data, instance->trans->params); } else if((instance->def->transaction_flags & TRANSACTION_TYPE_MASK) == TRANSACTION_RETRY) for(i = 0; i < instance->def->num_inputs; ++i) release_ref(instance->trans->params[i]); } else { for(i = 0; i < instance->trans->num_stores; ++i) release_ref(instance->trans->stores[i].instance_data); } VIS_FREE(instance->trans, "transaction"); } VIS_PROFILE_START(PROF_CLEANUP_CUSTOM); DEBUGPRINTF("Cleaning up custom worker: %s:%X\n", instance->def->name, instance); VIS_PROFILE_START(PROF_SUB_CALLBACK); if(instance->callback && do_commit) instance->callback(instance->caller_instance, instance->worker_in_caller, instance, instance->callback_data); //DEBUGPUTS("About to release refs\n"); VIS_PROFILE_END(PROF_SUB_CALLBACK); VIS_PROFILE_START(PROF_CLEANUP_RELEASE_REFS); /*for(i = 0; i < instance->def->implement_func->num_wires; ++i) { if(instance->wirelist[i].data) { DEBUGPRINTF("release_ref on wire %d\n", i); release_ref(instance->wirelist[i].data); } }*/ for(i = 0; i < instance->num_workers; ++i) { if(instance->def->implement_func->workerlist[i].type != WORKER && instance->def->implement_func->workerlist[i].type != TAIL_RECURSE && instance->def->implement_func->workerlist[i].type != TAIL_CALL && instance->workerlist[i].value) { DEBUGPRINTF( "release_ref on worker %d in instance %X\n", i, instance); release_ref(instance->workerlist[i].value); } if(instance->workerlist[i].ready_count && instance->workerlist[i].ready_count < (instance->def->implement_func->workerlist[i].num_inputs + (instance->def->implement_func->workerlist[i].null_input ? 1 : 0))) { DEBUGPRINTF("Freeing params for worker number %d, ready_count: %d, num_inputs: %d, null_input: %d, instance: %X\n", i, instance->workerlist[i].ready_count,instance->def->implement_func->workerlist[i].num_inputs, instance->def->implement_func->workerlist[i].null_input, instance); for(j = 0; j <= instance->def->implement_func->workerlist[i].num_inputs; ++j) { DEBUGPRINTF("Releasing param %d of worker %d\n", j, i); release_ref(instance->workerlist[i].params[j]); } } VIS_DeleteCriticalSection(instance->workerlist[i].worker_lock); } VIS_PROFILE_END(PROF_CLEANUP_RELEASE_REFS); VIS_DeleteCriticalSection(instance->counter_lock); //DEBUGPUTS("freeing lists\n"); #ifdef USER_PROFILE if(do_commit) { QueryPerformanceCounter(&end); duration.QuadPart = end.QuadPart - instance->start.QuadPart; VIS_EnterCriticalSection(instance->def->lock); instance->def->total.QuadPart += duration.QuadPart; ++instance->def->count; if(duration.QuadPart > instance->def->worst.QuadPart) instance->def->worst.QuadPart = duration.QuadPart; VIS_LeaveCriticalSection(instance->def->lock); } #endif /*VIS_PROFILE_START(PROF_CLEANUP_FREELISTS); free(instance->workerlist); free(instance->wirelist); VIS_PROFILE_END(PROF_CLEANUP_FREELISTS);*/ VIS_PROFILE_START(PROF_CLEANUP_CHECK); if(instance->caller_instance && do_commit) { incaller.worker_num = instance->worker_in_caller; incaller.instance = instance->caller_instance; DEBUGPUTS("Calling cleanup_check on parent\n"); cleanup_check(incaller); } if(do_commit && instance->callback == main_callback) release_program_ref(instance->def->program); VIS_PROFILE_END(PROF_CLEANUP_CHECK); VIS_PROFILE_START(PROF_CLEANUP_FREELISTS); VIS_FREE(instance, "worker instance"); VIS_PROFILE_END(PROF_CLEANUP_FREELISTS); VIS_PROFILE_END(PROF_CLEANUP_CUSTOM); } /* void worker_complete(queue_entry aworker) { int i,j; wire * wirelist; int * workers_to_wires_down; VIS_PROFILE_START(PROF_WORKER_COMPLETE); DEBUGPUTS("worker_complete()\n"); i = aworker.instance->def->implement_func->workerlist[aworker.worker_num].wire_down_lookup; wirelist = aworker.instance->def->implement_func->wirelist; workers_to_wires_down = aworker.instance->def->implement_func->workers_to_wires_down; while(wirelist[j=workers_to_wires_down[i]].start_worker == aworker.worker_num && j >= 0) { if(aworker.instance->wirelist[j].data) { DEBUGPRINTF("end_worker: %d, wirelist[%d].data = %X\n", wirelist[j].end_worker, j, aworker.instance->wirelist[j].data); add_if_ready(wirelist[j].end_worker, aworker.instance); } ++i; } DEBUGPUTS("worker_complete done\n"); VIS_PROFILE_END(PROF_WORKER_COMPLETE); }*/ void process_outputs(datum ** params, int aworker, worker_instance * instance) { BOOL flag=FALSE; int i,j; worker_def * def = instance->def; //custom_worker *implement_func = def->implement_func; wire * def_wires = def->implement_func->wirelist; worker * def_workers = def->implement_func->workerlist; VIS_PROFILE_START(PROF_PROCESS_OUTPUTS); DEBUGPRINTF("Process outputs for worker %d in instance %X\n", aworker, instance); DEBUGPRINTF("Num_inputs: %d, num_outputs: %d\n", def_workers[aworker].num_inputs, def_workers[aworker].num_outputs); if(def_workers[aworker].num_outputs && instance->workerlist) { //DEBUGPRINTF("num_outputs: %d\n", def_workers[aworker].num_outputs); i = def_workers[aworker].wire_down_lookup; while((j=def->implement_func->workers_to_wires_down[i]) >= 0 && def_wires[j].start_worker == aworker) { //DEBUGPRINTF("Checking output: %d\n", def_wires[j].output_num); DEBUGPRINTF("output[%d] = %X\n", def_wires[j].output_num, params[def_wires[j].output_num]); DEBUGPRINTF("wire leads to worker %d, instance->workerlist: %X\n", def_wires[j].end_worker, instance->workerlist); VIS_EnterCriticalSection(instance->workerlist[def_wires[j].end_worker].worker_lock); if(params[def_wires[j].output_num] && !instance->workerlist[def_wires[j].end_worker].params[def_wires[j].input_num+1]) { //DEBUGPRINTF( "add_ref on output %d\n", def_wires[j].output_num); instance->workerlist[def_wires[j].end_worker].params[def_wires[j].input_num+1]=add_ref(params[def_wires[j].output_num]); //DEBUGPRINTF("Ready count was: %d, ", instance->workerlist[def_wires[j].end_worker].ready_count); ++instance->workerlist[def_wires[j].end_worker].ready_count; DEBUGPRINTF("Ready count is now: %d\n", instance->workerlist[def_wires[j].end_worker].ready_count); DEBUGPRINTF("num inputs: %d, null input: %d\n", instance->def->implement_func->workerlist[def_wires[j].end_worker].num_inputs, instance->def->implement_func->workerlist[def_wires[j].end_worker].null_input); if(instance->workerlist[def_wires[j].end_worker].ready_count >= (instance->def->implement_func->workerlist[def_wires[j].end_worker].num_inputs + (instance->def->implement_func->workerlist[def_wires[j].end_worker].null_input ? 1 : 0))) { //DEBUGPUTS("flag = true\n"); flag = TRUE; instance->workerlist[def_wires[j].end_worker].ready_count=0; } } VIS_LeaveCriticalSection(instance->workerlist[def_wires[j].end_worker].worker_lock); if(flag) { DEBUGPUTS("add_queue\n"); add_queue(def_wires[j].end_worker, instance); //add_if_ready(def_wires[j].end_worker, instance); flag = FALSE; } ++i; } //DEBUGPUTS("releasing refs\n"); for(i = 0; i < def_workers[aworker].num_outputs; ++i) release_ref(params[i]); } VIS_PROFILE_END(PROF_PROCESS_OUTPUTS); } void main_callback(worker_instance * junkinst, int junk, worker_instance * main_instance, void * data) { //MessageBox(NULL, "Main Callback", "Visuality Debug", MB_OK); VIS_EnterCriticalSection(program_count_lock); --program_count; if(program_count <= 0) { execute_active = FALSE; VIS_SetEvent(queue_add_event); } VIS_LeaveCriticalSection(program_count_lock); if(data) release_ref((datum *)data); } void sub_callback(worker_instance * caller_instance, int caller_workernum, worker_instance * done_instance, void * data) { int i; queue_entry incaller; datum * params[32]; worker_def * def = done_instance->def; custom_worker * implement_func = def->implement_func; incaller.worker_num = caller_workernum; incaller.instance = caller_instance; for(i = 0; i < def->num_outputs; ++i) params[i] = NULL; for(i = 0; i < implement_func->num_workers; ++i) { if(implement_func->workerlist[i].type == 4) { if(!params[implement_func->workerlist[i].io_num]) { params[implement_func->workerlist[i].io_num] = done_instance->workerlist[i].value; DEBUGPRINTF("Output[%d] = %X\n", implement_func->workerlist[i].io_num, done_instance->workerlist[i].value); done_instance->workerlist[i].value = NULL; } } } process_outputs(params, caller_workernum, caller_instance); //worker_complete(incaller); } void pack_list_sub_callback(worker_instance * caller_instance, int caller_workernum, worker_instance * done_instance, void * data) { int i; queue_entry incaller; datum * params[32]; datum * workparams[2]; incaller.worker_num = caller_workernum; incaller.instance = caller_instance; for(i = 0; i < done_instance->def->num_outputs; ++i) params[i] = NULL; for(i = 0; i < done_instance->def->implement_func->num_workers; ++i) { if(done_instance->def->implement_func->workerlist[i].type == 4) { if(!params[done_instance->def->implement_func->workerlist[i].io_num]) { params[done_instance->def->implement_func->workerlist[i].io_num] = done_instance->workerlist[i].value; done_instance->workerlist[i].value = NULL; } } } workparams[0] = create_list(done_instance->def->program); for(i = 0; i < done_instance->def->num_outputs; ++i) { workparams[1] = params[i]; vis_list_append(workparams, NULL); } process_outputs(workparams, caller_workernum, caller_instance); //worker_complete(incaller); } void transaction_sub_callback(worker_instance * caller_instance, int caller_workernum, worker_instance * done_instance, void * data) { int i; pack_list_sub_callback(caller_instance, caller_workernum, done_instance, NULL); } int global_argc; char ** global_argv; int spin_counter; void prep_program(program * prog) { defchunk * current; int i,j; make_lookup_arrays(prog); current = prog->defs; while(current) { for(i = 0; i < current->num_defs; ++i) { #ifdef USER_PROFILE current->deflist[i].count = 0; current->deflist[i].total.QuadPart = 0; current->deflist[i].worst.QuadPart = 0; VIS_InitializeCriticalSection(current->deflist[i].lock); #endif // USER_PROFILE //DEBUGPRINTF("Checking worker %s with type %X\n", current->deflist[i].name, current->deflist[i].type); if(current->deflist[i].type & USER_FLAG && (current->deflist[i].type & TYPE_MASK) == WORKER_TYPE) { //DEBUGPRINTF("Checking for constants in worker %s\n", current->deflist[i].name); for(j = 0; j < current->deflist[i].implement_func->num_workers; ++j) if(current->deflist[i].implement_func->workerlist[j].type == CONSTANT) { //current->deflist[i].implement_func->workerlist[j].value_index = (int)(get_constant(current->deflist[i].implement_func->workerlist[j].name,-1, initial_prog)); //DEBUGPRINTF("Set value_index for constant to %X in worker %s at index %d\n", current->deflist[i].implement_func->workerlist[j].value_index, current->deflist[i].name, j); } else if(current->deflist[i].implement_func->workerlist[j].type == WORKER || current->deflist[i].implement_func->workerlist[j].type == TAIL_CALL || current->deflist[i].implement_func->workerlist[j].type == TAIL_RECURSE) { current->deflist[i].implement_func->workerlist[j].num_inputs = ((worker_def *)current->deflist[i].implement_func->workerlist[j].value_index)->num_inputs; current->deflist[i].implement_func->workerlist[j].num_outputs = ((worker_def *)current->deflist[i].implement_func->workerlist[j].value_index)->num_outputs; } else current->deflist[i].implement_func->workerlist[j].value_index = 0; //DEBUGPRINTF("optimize %d\n", i); #ifdef ENABLE_OPT optimize(current->deflist + i); #endif } } current = current->next; } } void interp_start(int num_threads, BOOL use_this_thread, int argc, char ** argv, program * initial_prog) { defchunk * current; datum * params[2]; int i, junk,create_threads,j; #ifdef USER_PROFILE LARGE_INTEGER frequency; #endif lock_fail_counter = 0; lock_counter = 0; spin_counter = 0; #ifdef WIN32 //_CrtSetDbgFlag(_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_CHECK_CRT_DF | _CRTDBG_ALLOC_MEM_DF); WSAStartup(MAKEWORD(1, 1), &wsa_data); #endif VIS_InitializeCriticalSection(randlock); DEBUGPUTS("interp_start\n"); #ifdef ENABLE_PROFILING for(i = 0; i < NUM_PROFS; ++i) { vis_profile_running_total[i] = 0; vis_profile_counts[i] = 0; } VIS_PROFILE_START(PROF_EMPTYFUNC); empty_test(NULL,NULL); VIS_PROFILE_END(PROF_EMPTYFUNC); VIS_PROFILE_START(PROF_NOCODE); VIS_PROFILE_END(PROF_NOCODE); #endif global_argc = argc; global_argv = argv; init_sync_primitives(); init_datum_storage(); init_global_storage(initial_prog); //init queue current_section = &first_section; DEBUGPRINTF("current_section = %X, ¤t_section = %X\n", current_section, ¤t_section); worker_queue = current_section->entries; current_section->last = NULL; current_section->next = NULL; queue_start = queue_len = 0; // deflist[0].num_workers = num_workers; // deflist[0].num_wires = num_wires; prep_program(initial_prog); //MessageBox(NULL, "Before fopen", "visdbg", MB_OK); init_genrand(time(NULL)); execute_active = TRUE; DEBUGPUTS("Before init_custom_worker on Main\n"); params[0] = create_list(initial_prog); for(i = 0; i < argc; ++i) { params[1] = make_string(argv[i], -1, initial_prog); vis_list_append(params, NULL); } main_instance = init_custom_worker(-1, NULL, initial_prog->defs->deflist, main_callback, NULL, params); //num_datum = 0; #if COMPILE_THREADS > 0 create_threads = COMPILE_THREADS; if(num_threads > 0) create_threads = num_threads; if(use_this_thread) --create_threads; for(i = 0; i < create_threads; ++i) { #ifdef WIN32 CreateThread(NULL, 0, worker_thread, NULL, 0, &junk); #else #ifdef SYLLABLE resume_thread(spawn_thread("vis_worker", worker_thread, 1, 0, NULL)); #else pthread_t pid; pthread_create(&pid, NULL, worker_thread, NULL); #endif #endif } if(use_this_thread) worker_thread(NULL); #else worker_thread(NULL); #endif #ifdef ENABLE_PROFILING for(i = 0; i < NUM_PROFS; ++i) printf("%d:\t%f,\tcount: %d,\taverage: %f\n", i, (double)vis_profile_running_total[i], vis_profile_counts[i], ((double)vis_profile_running_total[i])/((double)vis_profile_counts[i])); #endif #ifdef USER_PROFILE printf("%-33s%12s%7s%15s%12s\n\n", "Worker", "Total", "Count", "Average", "Worst"); current = initial_prog->defs; while(current) { for(i = 0; i < current->num_defs; ++i) { if(current->deflist[i].count > 0) { printf("%-33s%12.0f%7d%15.2f%12.0f\n", current->deflist[i].name, (double)current->deflist[i].total.QuadPart, current->deflist[i].count, (double)current->deflist[i].total.QuadPart / (double)current->deflist[i].count, (double)current->deflist[i].worst.QuadPart); } } current = current->next; } QueryPerformanceFrequency(&frequency); printf("%.0f ticks per second\n", (double)frequency.QuadPart); #endif interp_stop(); } void interp_stop() { int i; execute_active = FALSE; close_sync_primitives(); // Doesn't make sense in the context of multiple programs // cleanup_custom_worker(main_instance); #ifdef WIN32 WSACleanup(); #endif #ifdef TEXT_FILE_DEBUG fclose(debugfile); #endif } extern void init_sync_primitives() { int i; DEBUGPUTS("Initializing data_lock\n"); VIS_InitializeCriticalSection(data_lock); DEBUGPUTS("Initializing worker_queue_lock\n"); VIS_InitializeCriticalSection(worker_queue_lock); DEBUGPUTS("Initializing text_buf_lock\n"); VIS_InitializeCriticalSection(text_buf_lock); #ifdef GUI_LIB #ifdef SYLLABLE DEBUGPUTS("vis_window_init\n"); vis_window_init(); #endif #endif //GUI_LIB VIS_CreateEvent(queue_add_event);//No security parameter, auto reset, starts signaled, no name } void close_sync_primitives() { int i; VIS_DeleteCriticalSection(data_lock); VIS_DeleteCriticalSection(worker_queue_lock); VIS_DestroyEvent(queue_add_event); } void init_global_storage(program * prog) { VIS_InitializeCriticalSection(global_store_lock); global_store_dict = create_dict(prog); } void add_multiple(int * data, int num, worker_instance * instance) { int i, index; queue_section * temp; DEBUGPRINTF( "Adding %d workers\n", num); VIS_EnterCriticalSection(instance->counter_lock); instance->in_queue_count += num; VIS_LeaveCriticalSection(instance->counter_lock); VIS_EnterCriticalSection(worker_queue_lock); for(i = 0; i < num; ++i) { if(queue_len >= QUEUE_SIZE) { if(current_section->next) { //DEBUGPUTS("Moving to next queue_section\n"); current_section = current_section->next; } else { //DEBUGPUTS("Allocating new queue_section\n"); VIS_PROFILE_START(PROF_ADDQUEUE_MALLOC); temp = MALLOC(sizeof(queue_section),"queue section"); VIS_PROFILE_END(PROF_ADDQUEUE_MALLOC); temp->last = current_section; temp->next = NULL; current_section->next = temp; current_section = temp; } worker_queue = current_section->entries; queue_start = queue_len = 0; } if(queue_start+queue_len < QUEUE_SIZE) index = queue_start+queue_len; else index = queue_start+queue_len-QUEUE_SIZE; worker_queue[index].worker_num=data[i]; worker_queue[index].instance = instance; ++queue_len; } VIS_LeaveCriticalSection(worker_queue_lock); //DEBUGPUTS("SetEvent\n"); VIS_SetEvent(queue_add_event); } void requeue(int data, worker_instance * instance) { add_queue(data, instance); VIS_EnterCriticalSection(instance->counter_lock); --(instance->in_progress_count); VIS_LeaveCriticalSection(instance->counter_lock); } void add_queue(int data, worker_instance * instance) { int index; queue_section * temp; VIS_PROFILE_START(PROF_ADDQUEUE); VIS_EnterCriticalSection(instance->counter_lock); ++(instance->in_queue_count); VIS_LeaveCriticalSection(instance->counter_lock); VIS_EnterCriticalSection(worker_queue_lock); if(queue_len >= QUEUE_SIZE) { if(current_section->next) { //DEBUGPUTS("Moving to next queue_section\n"); current_section = current_section->next; } else { //DEBUGPUTS("Allocating new queue_section\n"); VIS_PROFILE_START(PROF_ADDQUEUE_MALLOC); temp = MALLOC(sizeof(queue_section),"queue section"); VIS_PROFILE_END(PROF_ADDQUEUE_MALLOC); temp->last = current_section; temp->next = NULL; current_section->next = temp; current_section = temp; } worker_queue = current_section->entries; queue_start = queue_len = 0; } else if(queue_len == 0) { VIS_SetEvent(queue_add_event); //DEBUGPUTS("SetEvent\n"); } if(queue_start+queue_len < QUEUE_SIZE) index = queue_start+queue_len; else index = queue_start+queue_len-QUEUE_SIZE; worker_queue[index].worker_num=data; worker_queue[index].instance = instance; ++queue_len; VIS_LeaveCriticalSection(worker_queue_lock); VIS_PROFILE_END(PROF_ADDQUEUE); } /** * Retrieves a ready worker from the queue */ queue_entry get_queue() { queue_entry data; queue_section * temp; //DEBUGPUTS("Begin get_queue()\n"); VIS_EnterCriticalSection(worker_queue_lock); while(!queue_len && execute_active) { //DEBUGPUTS("Queue empty, resetting event\n"); VIS_ResetEvent(queue_add_event); VIS_LeaveCriticalSection(worker_queue_lock); //DEBUGPUTS("Waiting for queue_add_event\n"); VIS_WaitEvent(queue_add_event); #ifdef NINTENDO_DS //TODO make the processor sleep while waiting for IRQs if(irq_queue_count > 0) run_queued_irqs(); #endif VIS_EnterCriticalSection(worker_queue_lock); } if(queue_len > 0) { data = worker_queue[queue_start]; //DEBUGPRINTF( "Next worker in queue: %d\n", data.worker_num); //DEBUGPRINTF("data.instance: %X, data.instance->workerlist: %X\n", data.instance, data.instance->workerlist); /*VIS_EnterCriticalSection(data.instance->workerlist[data.worker_num].worker_lock); DEBUGPUTS("Adjusting ready_count"); data.instance->workerlist[data.worker_num].ready_count=0; VIS_LeaveCriticalSection(data.instance->workerlist[data.worker_num].worker_lock);*/ ++queue_start; --queue_len; //DEBUGPUTS("Adjusted ready count.\n"); //DEBUGPRINTF("current_section: %X\n", current_section); if(queue_len == 0 && current_section->last) { if(current_section->next != NULL) { //DEBUGPUTS("Freeing current_section->next.\n"); VIS_FREE(current_section->next, "ready queue node"); current_section->next = NULL; } current_section = current_section->last; worker_queue = current_section->entries; queue_start = 0; queue_len = QUEUE_SIZE; } else if(queue_start == QUEUE_SIZE) queue_start = 0; } else { //DEBUGPUTS("Queue empty\n"); data.worker_num = -2; } VIS_LeaveCriticalSection(worker_queue_lock); //DEBUGPUTS("Left worker_queue_lock\n"); //MessageBox(NULL,"AfterLeave","visdbg",MB_OK); if(data.worker_num >= 0) { VIS_EnterCriticalSection(data.instance->counter_lock); //DEBUGPUTS("Adjusting in_queue/in_progress counts.\n"); --(data.instance->in_queue_count); ++(data.instance->in_progress_count); DEBUGPRINTF( "Counts for %s<%d> Instance:%X after get_queue: in_queue: %d in_progress: %d\n",data.instance->def->name, data.instance->worker_in_caller, data.instance, data.instance->in_queue_count, data.instance->in_progress_count); VIS_LeaveCriticalSection(data.instance->counter_lock); } //DEBUGPUTS("End get_queue()\n"); return data; } void def_make_lookup(worker_def * def) { int i, j, upoffset, offset; VIS_EnterCriticalSection(def->implement_func->lock); if(def->implement_func->dirty) { upoffset = offset = 0; for(i = 0; i < def->implement_func->num_workers; ++i) { def->implement_func->workerlist[i].wire_down_lookup=offset; def->implement_func->workerlist[i].wire_up_lookup=upoffset; for(j = 0; j < def->implement_func->num_wires; ++j) { if(def->implement_func->wirelist[j].start_worker == i) def->implement_func->workers_to_wires_down[offset++]=j; if(def->implement_func->wirelist[j].end_worker == i) def->implement_func->workers_to_wires_up[upoffset++]=j; } //Clear tail call info if(def->implement_func->workerlist[i].type == TAIL_CALL || def->implement_func->workerlist[i].type == TAIL_RECURSE) def->implement_func->workerlist[i].type = WORKER; } def->implement_func->workers_to_wires_down[offset]=-1; def->implement_func->workers_to_wires_up[upoffset]=-1; check_tail(def); def->implement_func->dirty = FALSE; } VIS_LeaveCriticalSection(def->implement_func->lock); } /** * Generates lookup array to ease navigation between workers */ void make_lookup_arrays(program * prog) { int i,j,k, offset, upoffset; worker_def * deflist; defchunk * current = prog->defs; while(current) { deflist = current->deflist; for(k = 0; k < current->num_defs; ++k) { if(deflist[k].type & USER_FLAG && (deflist[k].type & TYPE_MASK) == WORKER_TYPE) def_make_lookup(deflist + k); } current = current->next; } } extern char _end_bss[]; void initpredefworkers(program * prog) { int current_def = 1; int current_company = 0; int current_method; int comp_room; company * this_comp; worker_def * aworker; create_company(prog, "Any Type", 0, 0, FALSE); create_company(prog, "Yes No", 0, 0, FALSE); aworker = create_worker(prog, "Print", 1, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_print; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Random", 0, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_random; aworker = create_worker(prog, "Build", 1, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_build; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "End", 1, 0, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_end; aworker->input_types[0] = ANY_TYPE; create_worker(prog, "Append", 2, 1, MAGIC_TYPE); create_worker(prog, "+", 2, 1, MAGIC_TYPE); create_worker(prog, "-", 2, 1, MAGIC_TYPE); create_worker(prog, "*", 2, 1, MAGIC_TYPE); create_worker(prog, "/", 2, 1, MAGIC_TYPE); create_worker(prog, ">", 2, 1, MAGIC_TYPE); create_worker(prog, "<", 2, 1, MAGIC_TYPE); create_worker(prog, "=", 2, 1, MAGIC_TYPE); aworker = create_worker(prog, "Get Input", 0, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_getinput; aworker = create_worker(prog, "If",1, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_if; aworker->input_types[0] = BUILTIN_TYPE_YESNO; aworker = create_worker(prog, "Type Of",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_type_of; aworker->input_types[0] = ANY_TYPE; aworker = create_worker(prog, "Init Store",1, 0, WORKER_TYPE); aworker->implement_func=(custom_worker *)init_global_store; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Wait Forever", 0, 0, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_wait_forever; #ifdef NINTENDO_DS aworker = create_worker(prog, "Register Handler", 2, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_register_handler; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WORKER; aworker = create_worker(prog, "Clear Handler", 1, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_clear_handler; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Held Keys", 0, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_held_keys; aworker = create_worker(prog, "Touch Position", 0, 2, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_touch_position; #endif current_method = 0; //strcpy(companylist[current_company].name, "String"); #ifdef SEGA this_comp = create_company(prog, "String", 6, 0, FALSE); #else this_comp = create_company(prog, "String", 7, 0, FALSE); #endif aworker = create_worker(prog, "<Whole Number@String",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_inttostring; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); #ifndef SEGA aworker = create_worker(prog, "<Real Number@String",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_realtostring; aworker->input_types[0] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); #endif aworker = create_worker(prog, "=@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_stringequal; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "<Yes No@String",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_yesnotostring; aworker->input_types[0] = BUILTIN_TYPE_YESNO; //add_method(this_comp, aworker); aworker = create_worker(prog, ">@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_greaterstring; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "<@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_lesserstring; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Append@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_append; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Split@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_split; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Get Raw@String",2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_get_raw; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Put Raw@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_put_raw; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Slice@String",2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_slice; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Reverse@String",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_reverse; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Length@String",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_length; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Put Byte@String",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_put_byte; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Get DString@String",2, 4, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_string_get_dstring; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = ANY_TYPE; current_method = 0; this_comp = create_company(prog, "Whole Number", 6, 0, FALSE); aworker = create_worker(prog, "<String@Whole Number",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_stringtoint; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "From Hex@Whole Number",1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_fromhex; aworker->input_types[0] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "=@Whole Number",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_wholeequal; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, ">@Whole Number",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_greaterint; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "<@Whole Number",2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_lesserint; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "+@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_add; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "-@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_subtract; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "*@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_mult; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "/@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_div; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "&@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_and; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "|@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_or; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "LShift@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_lsh; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "RShift@Whole Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_whole_rsh; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); current_method = 0; this_comp = create_company(prog, "Real Number", 6, 0, FALSE);//<string, =, >, <, +, - aworker = create_worker(prog, "<String@Real Number", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_stringtoreal; aworker->input_types[0] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "=@Real Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_realequal; aworker->input_types[0] = BUILTIN_TYPE_REAL; aworker->input_types[1] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, ">@Real Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_greaterreal; aworker->input_types[0] = BUILTIN_TYPE_REAL; aworker->input_types[1] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "<@Real Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_lesserreal; aworker->input_types[0] = BUILTIN_TYPE_REAL; aworker->input_types[1] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "+@Real Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_real_add; aworker->input_types[0] = BUILTIN_TYPE_REAL; aworker->input_types[1] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "-@Real Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_real_subtract; aworker->input_types[0] = BUILTIN_TYPE_REAL; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker = create_worker(prog, "/@Real Number", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_real_div; aworker->input_types[0] = BUILTIN_TYPE_REAL; aworker->input_types[1] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); current_method = 0; this_comp = create_company(prog, "List", 7, 1, FALSE);//Index, Append, Swap, Insert, Remove, Set, Length, New comp_room = add_comp_room(this_comp, "Length", 0, 0, ROOM_NO_ACCESS, ROOM_LONG); aworker = create_worker(prog, "Index@List", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_index; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Append@List", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_append; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = ANY_TYPE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Swap@List",3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_swap; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Insert@List",3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_insert; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = ANY_TYPE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Remove@List", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_remove; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Set@List",3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_set; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = ANY_TYPE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Length@List", 1, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_list_length; aworker->input_types[0] = BUILTIN_TYPE_LIST; //add_method(this_comp, aworker); aworker = create_worker(prog, "New@List",0, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_new; //add_method(this_comp, aworker); aworker = create_worker(prog, "First@List", 1, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_first; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker = create_worker(prog, "Next@List", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_list_next; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; current_method = 0; this_comp = create_company(prog, "Dictionary", 5, 0, FALSE);//Index, Swap, Remove, Set, Length, New aworker = create_worker(prog, "Index@Dictionary", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_index; aworker->input_types[0] = BUILTIN_TYPE_DICT; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Swap@Dictionary",3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_swap; aworker->input_types[0] = BUILTIN_TYPE_DICT; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Remove@Dictionary", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_remove; aworker->input_types[0] = BUILTIN_TYPE_DICT; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Set@Dictionary",3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_set; aworker->input_types[0] = BUILTIN_TYPE_DICT; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = ANY_TYPE; aworker = create_worker(prog, "Length@Dictionary", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_length; aworker->input_types[0] = BUILTIN_TYPE_DICT; //add_method(this_comp, aworker); aworker = create_worker(prog, "New@Dictionary",0, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_new; //add_method(this_comp, aworker); aworker = create_worker(prog, "First@Dictionary", 1, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_first; aworker->input_types[0] = BUILTIN_TYPE_DICT; aworker = create_worker(prog, "Next@Dictionary", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dict_next; aworker->input_types[0] = BUILTIN_TYPE_DICT; aworker->input_types[1] = BUILTIN_TYPE_STRING; current_method = 0; #ifdef SEGA this_comp = create_company(prog, "File", 0, 0, FALSE); #else this_comp = create_company(prog, "File", 7, 0, FALSE);//<String, Get FString, Get DString, Get Byte, Get Word, Get Long, Put String aworker = create_worker(prog, "<String@File", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_from_string; aworker->input_types[0] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Get FString@File", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_get_fstring; aworker->input_types[0] = BUILTIN_TYPE_FILE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Get DString@File", 2, 4, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_get_dstring; aworker->input_types[0] = BUILTIN_TYPE_FILE; aworker->input_types[1] = ANY_TYPE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Get Byte@File", 1, 3, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_get_byte; aworker->input_types[0] = BUILTIN_TYPE_FILE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Get Word@File", 1, 3, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_get_word; aworker->input_types[0] = BUILTIN_TYPE_FILE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Get Long@File", 1, 3, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_get_long; aworker->input_types[0] = BUILTIN_TYPE_FILE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Put String@File", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_put_string; aworker->input_types[0] = BUILTIN_TYPE_FILE; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Length@File", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_file_length; aworker->input_types[0] = BUILTIN_TYPE_FILE; //add_method(this_comp, aworker); #endif current_method = 0; this_comp = create_company(prog, "Worker", 3, 0, FALSE);//<String, Do, Later: methods for manipulating aworker = create_worker(prog, "<String@Worker", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_from_string; aworker->input_types[0] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Do@Worker", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_do; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_LIST; aworker = create_worker(prog, "Set Input@Worker", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_setinput; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = ANY_TYPE; //add_method(this_comp, aworker); aworker = create_worker(prog, "Add Worker Call@Worker", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_worker_call; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_WORKER; aworker = create_worker(prog, "Add Wire@Worker", 5, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_wire; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = BUILTIN_TYPE_WHOLE; aworker->input_types[3] = BUILTIN_TYPE_WHOLE; aworker->input_types[4] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Add Constant@Worker", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_constant; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Add Input@Worker", 3, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_input; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Add Output@Worker", 3, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_output; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Add Object Get@Worker", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_objectget; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Add Object Set@Worker", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_objectset; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Add Global Get@Worker", 3, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_globalget; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Add Global Set@Worker", 3, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_add_globalset; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Clear@Worker", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_clear; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker = create_worker(prog, "Uses@Worker", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_uses; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_LIST; aworker = create_worker(prog, "Set IO Counts@Worker", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_setio_counts; aworker->input_types[0] = BUILTIN_TYPE_WORKER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "New@Worker", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_worker_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; #ifdef GUI_LIB current_method = 0; this_comp = create_company(prog, "Window", 3, 0, FALSE); aworker = create_worker(prog, "New@Window", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "Add Widget@Window", 5, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_add_widget; aworker->input_types[0] = BUILTIN_TYPE_WINDOW; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = ANY_TYPE; aworker->input_types[3] = BUILTIN_TYPE_REAL; aworker->input_types[4] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "Show@Window", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_show; aworker->input_types[0] = BUILTIN_TYPE_WINDOW; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); current_method = 0; this_comp = create_company(prog, "Screen Window", 3, 0, FALSE); aworker = create_worker(prog, "Get Value@Screen Window", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_get_value; aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); aworker = create_worker(prog, "Set Value@Screen Window", 3, 0, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_set_value; aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; aworker->input_types[1] = BUILTIN_TYPE_STRING; #ifdef SYLLABLE aworker->input_types[2] = ANY_TYPE; #else aworker->input_types[2] = BUILTIN_TYPE_STRING; #endif //add_method(this_comp, aworker); aworker = create_worker(prog, "Wait Close@Screen Window", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_wait_close; aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; //add_method(this_comp, aworker); #ifdef SYLLABLE aworker = create_worker(prog, "Add Widget@Screen Window", 5, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_window_shown_addwidget; aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = ANY_TYPE; aworker->input_types[3] = BUILTIN_TYPE_REAL; aworker->input_types[4] = BUILTIN_TYPE_REAL; #endif current_method = 0; create_company(prog, "Button", 2, 0, FALSE); aworker = create_worker(prog, "New@Button", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_button_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "Set Handler@Button", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_button_set_handler; aworker->input_types[0] = BUILTIN_TYPE_BUTTON; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WORKER; //add_method(this_comp, aworker); current_method = 0; create_company(prog, "Input Box", 2, 0, FALSE); aworker = create_worker(prog, "New@Input Box", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_inputbox_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "Set Type@Input Box", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_inputbox_settype; aworker->input_types[0] = BUILTIN_TYPE_INPUTBOX; aworker->input_types[1] = BUILTIN_TYPE_STRING; //add_method(this_comp, aworker); #endif #ifndef NO_NET this_comp = create_company(prog, "Net Client", 3, 0, FALSE); aworker = create_worker(prog, "New@Net Client", 2, 1, WORKER_TYPE); aworker->implement_func =(custom_worker *)net_client_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Put String@Net Client", 2, 2, WORKER_TYPE); aworker->implement_func = (custom_worker *)net_client_put_string; aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Get FString@Net Client", 2, 3, WORKER_TYPE); aworker->implement_func = (custom_worker *)net_client_get_fstring; aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Get DString@Net Client", 2, 4, WORKER_TYPE); aworker->implement_func = (custom_worker *)net_client_get_dstring; aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Put Raw@Net Client", 2, 2, WORKER_TYPE); aworker->implement_func = (custom_worker *)net_client_put_raw; aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Get Raw@Net Client", 2, 3, WORKER_TYPE); aworker->implement_func = (custom_worker *)net_client_get_raw; aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Listen on Port", 2, 0, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_net_listenport; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WORKER; #endif create_company(prog, "Global Store", 0, 0, FALSE); create_company(prog, "Program", 5, 0, FALSE); aworker = create_worker(prog, "New@Program", 0, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_program_new; aworker = create_worker(prog, "New Worker@Program", 2, 2, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_program_new_worker; aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Add Worker@Program", 2, 2, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_program_add_worker; aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; aworker->input_types[1] = BUILTIN_TYPE_WORKER; aworker = create_worker(prog, "Add Builtins@Program", 1, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_program_add_builtins; aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; aworker = create_worker(prog, "Run@Program", 2, 1, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_program_run; aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; aworker->input_types[1] = ANY_TYPE; aworker = create_worker(prog, "Find Worker@Program", 2, 2, WORKER_TYPE); aworker->implement_func = (custom_worker *)vis_program_find_worker; aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; aworker->input_types[1] = BUILTIN_TYPE_STRING; #ifdef GUI_LIB #ifdef SYLLABLE create_company(prog, "Custom Widget", 2, 0, FALSE); aworker = create_worker(prog, "New@Custom Widget", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_customwidget_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "Set Handler@Custom Widget", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_button_set_handler; aworker->input_types[0] = BUILTIN_TYPE_CUSTOM_WIDGET; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WORKER; //add_method(this_comp, aworker); create_company(prog, "Screen Custom Widget", 3, 0, FALSE); aworker = create_worker(prog, "Default Draw@Screen Custom Widget", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_defaultpaint; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; //add_method(this_comp, aworker); aworker = create_worker(prog, "Draw Line@Screen Custom Widget", 5, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_drawline; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; aworker->input_types[3] = BUILTIN_TYPE_REAL; aworker->input_types[4] = BUILTIN_TYPE_REAL; //add_method(this_comp, aworker); aworker = create_worker(prog, "Draw String@Screen Custom Widget", 4, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_drawstring; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_REAL; aworker->input_types[3] = BUILTIN_TYPE_REAL; aworker = create_worker(prog, "Set Draw Color@Screen Custom Widget", 5, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_setdrawcolor; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker->input_types[2] = BUILTIN_TYPE_WHOLE; aworker->input_types[3] = BUILTIN_TYPE_WHOLE; aworker->input_types[4] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Move By@Screen Custom Widget", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_moveby; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; aworker = create_worker(prog, "Set Handler@Screen Custom Widget", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_sethandler; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WORKER; aworker = create_worker(prog, "Remove Handler@Screen Custom Widget", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_removehandler; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Give Focus@Screen Custom Widget", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_givefocus; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_YESNO; aworker = create_worker(prog, "Add Widget@Screen Custom Widget", 5, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_screen_custom_addwidget; aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = ANY_TYPE; aworker->input_types[3] = BUILTIN_TYPE_REAL; aworker->input_types[4] = BUILTIN_TYPE_REAL; #endif #endif create_company(prog, "Buffer", 7, 0, FALSE); aworker = create_worker(prog, "New@Buffer", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_new; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Lock@Buffer", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_lock; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker = create_worker(prog, "Unlock@Buffer", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_unlock; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker = create_worker(prog, "Put Byte@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_putbyte; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Write Byte@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_writebyte; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Put Word@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_putshort; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Write Word@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_writeshort; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Put Long@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_putlong; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Write Long@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_writelong; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; aworker = create_worker(prog, "Reset@Buffer", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_reset; aworker->input_types[0] = BUILTIN_TYPE_BUFFER; #if defined(SEGA) || defined(NINTENDO_DS) aworker = create_worker(prog, "From Address@Buffer", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_buffer_fromaddress; aworker->input_types[0] = BUILTIN_TYPE_WHOLE; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; #endif //SEGA create_company(prog, "Blueprint", 4, 0, FALSE); aworker = create_worker(prog, "New@Blueprint", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_blueprint_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Add Field@Blueprint", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_blueprint_addfield; aworker->input_types[0] = BUILTIN_TYPE_BLUEPRINT; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Name@Blueprint", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_blueprint_name; aworker->input_types[0] = BUILTIN_TYPE_BLUEPRINT; aworker = create_worker(prog, "Get Fields@Blueprint", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_blueprint_getfields; aworker->input_types[0] = BUILTIN_TYPE_BLUEPRINT; aworker = create_worker(prog, "Blueprint Of", 1, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_get_blueprint; aworker->input_types[0] = ANY_TYPE; aworker = create_worker(prog, "Get Field", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_get_field; aworker->input_types[0] = ANY_TYPE; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Set Field", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_set_field; aworker->input_types[0] = ANY_TYPE; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = ANY_TYPE; aworker = create_worker(prog, "New Blueprint@Program", 2, 2, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_program_newblueprint; aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; aworker->input_types[1] = BUILTIN_TYPE_STRING; #ifdef GUI_LIB #ifdef SYLLABLE create_company(prog, "Checkbox", 2, 0, FALSE); aworker = create_worker(prog, "New@Checkbox", 4, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_checkbox_new; aworker->input_types[0] = BUILTIN_TYPE_STRING; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; aworker->input_types[3] = BUILTIN_TYPE_YESNO; aworker = create_worker(prog, "Set Handler@Checkbox", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_button_set_handler; aworker->input_types[0] = BUILTIN_TYPE_CHECKBOX; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WORKER; create_company(prog, "Dropdown", 4, 0, FALSE); aworker = create_worker(prog, "New@Dropdown", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dropdown_new; aworker->input_types[0] = BUILTIN_TYPE_LIST; aworker->input_types[1] = BUILTIN_TYPE_REAL; aworker->input_types[2] = BUILTIN_TYPE_REAL; aworker = create_worker(prog, "Set Handler@Dropdown", 3, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_button_set_handler; aworker->input_types[0] = BUILTIN_TYPE_DROPDOWN; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker->input_types[2] = BUILTIN_TYPE_WORKER; aworker = create_worker(prog, "Set Text@Dropdown", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dropdown_settext; aworker->input_types[0] = BUILTIN_TYPE_DROPDOWN; aworker->input_types[1] = BUILTIN_TYPE_STRING; aworker = create_worker(prog, "Select@Dropdown", 2, 1, WORKER_TYPE); aworker->implement_func=(custom_worker *)vis_dropdown_select; aworker->input_types[0] = BUILTIN_TYPE_DROPDOWN; aworker->input_types[1] = BUILTIN_TYPE_WHOLE; #endif #endif /*if(current_def > num_defs) num_defs = current_def; if(current_company > num_companies) num_companies = current_company;*/ } void initworkers(program * prog) { //num_defs=0; //num_companies=0; create_worker(prog, "Main", 0, 0, USER_FLAG | WORKER_TYPE); initpredefworkers(prog); } /* void add_if_ready(int workerNum, worker_instance * instance) { //int i, j, n, old_ready_count; BOOL ready=FALSE; //int paramstore[32]; //int * params = paramstore; DEBUGPUTS("add_if_ready\n"); if(!instance || !instance->def) return; VIS_PROFILE_START(PROF_ADDREADY); DEBUGPRINTF( "add_if_ready on %s\n", instance->def->implement_func->workerlist[workerNum].name); VIS_EnterCriticalSection(instance->workerlist[workerNum].worker_lock); ++instance->workerlist[workerNum].ready_count; if(instance->workerlist[workerNum].ready_count >= (instance->def->implement_func->workerlist[workerNum].num_inputs + (instance->def->implement_func->workerlist[workerNum].null_input ? 1 : 0))) { ready = TRUE; instance->workerlist[workerNum].ready_count = 0; } VIS_LeaveCriticalSection(instance->workerlist[workerNum].worker_lock); if(ready) { DEBUGPRINTF("add_queue on %s\n", instance->def->implement_func->workerlist[workerNum].name); add_queue(workerNum, instance); } VIS_PROFILE_END(PROF_ADDREADY); }*/ #define RETURN_CODE_EXIT 0xABCE1234 #define RETURN_CODE_IDLE 0x00BADFAD #define RETURN_CODE_NORMAL 0xABBAABBA #define RETURN_CODE_PARALLEL 0xC001D00D #define GET_OP1(opcode) ((opcode & 0xF0000000) >> 28) #define GET_OP2(opcode) ((opcode & 0x0F000000) >> 24) #define GET_INST(opcode) ((opcode & 0x00FF0000) >> 16) #define MOVE_INST 0x00 #define ADDREF_INST 0x01 #define RELEASE_INST 0x02 #define LOAD_INST 0x03 #define CALL_INST 0x04 #define CALLB_INST 0x05 #define CALLP_INST 0x06 #define CALLBP_INST 0x07 #define RETURN_INST 0x08 #define BRANCH_INST 0x09 #define BRANCHT_INST 0x0A #define BRANCHF_INST 0x0B #define WAIT_INST 0x0C #define ADD_INST 0x0D #define SUB_INST 0x0E #define SUBR_INST 0x0F #define GREATER_INST 0x10 #define LESSER_INST 0x11 #define REGISTER_BIT 0x8 #define NO_OPERAND 0x7 #define OP_REG_MASK 0x7 #define GET_REGNUM1(opcode) ((opcode & 0x0000FF00) >> 8) #define GET_REGNUM2(opcode) (opcode & 0x000000FF) #define REG_DIRECT 0 #define REG_INDIRECT 1 #define IMMED_8 2 #define IMMED_32 3 #define STACK_8 4 #define REG_REL_32 5 #define PC_REL_8 6 #define STACK_REG 31 #define PC_REG 30 #define OPC(inst, op1, reg1, op2, reg2) ((op1 << 28) | (op2 << 24) | (inst << 16) | ((reg1 & 0xff) << 8) | (reg2 & 0xFF)) //unsigned long test_program[] = //{ // OPC(LOAD_INST, PC_REL_8, 8 /* Hi */, REG_DIRECT, 0), // OPC(CALLB_INST, IMMED_8, 1/* Print */, NO_OPERAND, 0), // OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), // 26952//Hi //}; unsigned long test_program[] = { //Main: OPC(LOAD_INST, PC_REL_8, 20/* 10 */, REG_DIRECT, 0), OPC(LOAD_INST, PC_REL_8, 20/* 2 */, PC_REL_8, 28), OPC(LOAD_INST, PC_REL_8, 20/* 1 */, PC_REL_8, 28), OPC(CALL_INST, PC_REL_8, 28/* Fib: */, NO_OPERAND, 0), OPC(CALLB_INST, IMMED_8, 1/* Print */, NO_OPERAND, 0), OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), 0x3033,//'30' 0x32,//'2' 0x31,//'1' 0,//2 storage 0,//1 storage //Fib: OPC(ADD_INST, IMMED_8, 8, REG_DIRECT, STACK_REG), OPC(MOVE_INST, REG_DIRECT, 0, STACK_8, -4), OPC(ADDREF_INST, REG_INDIRECT, 0, NO_OPERAND, 0), OPC(ADDREF_INST, REG_INDIRECT, 0, NO_OPERAND, 0), OPC(MOVE_INST, PC_REL_8, -28/* 2 */, REG_DIRECT, 1), OPC(ADDREF_INST, REG_INDIRECT, 1, NO_OPERAND, 0), OPC(CALLB_INST, IMMED_8, 8/* < */, NO_OPERAND, 0), OPC(CALLB_INST, IMMED_8, 11/* If */, NO_OPERAND, 0), OPC(BRANCHT_INST, PC_REL_8, 64/* _Base */, REG_DIRECT, 0), OPC(RELEASE_INST, REG_INDIRECT, 1, NO_OPERAND, 0), OPC(MOVE_INST, STACK_8, -4, REG_DIRECT, 0), OPC(MOVE_INST, PC_REL_8, -56/* 2 */, REG_DIRECT, 1), OPC(ADDREF_INST, REG_INDIRECT, 1, NO_OPERAND, 0), OPC(CALLB_INST, IMMED_8, 6/* - */, NO_OPERAND, 0), OPC(CALL_INST, PC_REL_8, -60/* Fib */, NO_OPERAND, 0), OPC(MOVE_INST, REG_DIRECT, 0, STACK_8, -8), OPC(MOVE_INST, STACK_8, -4, REG_DIRECT, 0), OPC(MOVE_INST, PC_REL_8, -76/* 1 */, REG_DIRECT, 1), OPC(ADDREF_INST, REG_INDIRECT, 1, NO_OPERAND, 0), OPC(CALLB_INST, IMMED_8, 6/* - */, NO_OPERAND, 0), OPC(CALL_INST, PC_REL_8, -84/* Fib */, NO_OPERAND, 0), OPC(MOVE_INST, STACK_8, -8, REG_DIRECT, 1), OPC(CALLB_INST, IMMED_8, 5/* + */, NO_OPERAND, 0), OPC(SUBR_INST, IMMED_8, 8, REG_DIRECT, STACK_REG), OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), //_Base: OPC(RELEASE_INST, REG_INDIRECT, 0, NO_OPERAND, 0), OPC(MOVE_INST, PC_REL_8, -112/* 1 */, REG_DIRECT, 0), OPC(ADDREF_INST, REG_INDIRECT, 0, NO_OPERAND, 0), OPC(SUBR_INST, IMMED_8, 8, REG_DIRECT, STACK_REG), OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), }; unsigned long * get_effective_address(char op, unsigned short regnum, unsigned long ** pc, unsigned long * registers, unsigned long * immed) { unsigned long * add = NULL; unsigned long work; if(op != NO_OPERAND) { if(op & REGISTER_BIT) add = (unsigned long *)(registers[regnum] + registers[op & OP_REG_MASK]); else { switch(op) { case REG_DIRECT: add = registers + regnum; break; case REG_INDIRECT: add = (unsigned long *) registers[regnum]; break; case IMMED_8: *immed = (char)regnum; add = (unsigned long *)immed; break; case IMMED_32: *immed = *((*pc)++); add = (unsigned long *)immed; break; case STACK_8: work = (char)regnum; add = (unsigned long *)(registers[STACK_REG] + work); break; case REG_REL_32: work = *((*pc)++); add = (unsigned long *)(registers[regnum] + work); break; case PC_REL_8: work = (char)regnum; add = (unsigned long *)(registers[PC_REG] + work); break; default: break; } } } return add; } DWORD WINAPI virtual_processor(unsigned long * program, BOOL main) { int i; unsigned long **pc; unsigned long **stack; unsigned long registers[32]; unsigned long opcode; unsigned long extra, extra2; queue_entry entry; stack_segment initial_stack; stack_segment * current = &initial_stack; char slot_usage[7]; char op1, op2; char inst; unsigned long *add1, *add2; long immed1, immed2; initial_stack.size = MIN_STACK_SIZE; initial_stack.parent = initial_stack.child = NULL; initial_stack.data[0] = main ? RETURN_CODE_EXIT : RETURN_CODE_IDLE; pc = (unsigned long **)(&(registers[PC_REG])); stack = (unsigned long **)(&(registers[STACK_REG])); *pc = program; *stack = (unsigned long *)(initial_stack.data + 1); entry.instance = NULL; entry.worker_num = 0; DEBUGPRINTF("Virtual processor, Program start: %X\n", program); #ifdef ENABLE_PROFILING for(i = 0; i < NUM_PROFS; ++i) { vis_profile_running_total[i] = 0; vis_profile_counts[i] = 0; } VIS_PROFILE_START(PROF_EMPTYFUNC); empty_test(NULL,NULL); VIS_PROFILE_END(PROF_EMPTYFUNC); VIS_PROFILE_START(PROF_NOCODE); VIS_PROFILE_END(PROF_NOCODE); #endif while(execute_active) { VIS_PROFILE_START(PROF_VIRTUAL_DECODE); DEBUGPRINTF("PC: %X\n", *pc); opcode = *((*pc)++); op1 = GET_OP1(opcode); op2 = GET_OP2(opcode); add1 = get_effective_address(op1, GET_REGNUM1(opcode), pc, registers, &immed1); add2 = get_effective_address(op2, GET_REGNUM2(opcode), pc, registers, &immed2); DEBUGPRINTF("Opcode: %X, Instruction: %X, op1 %X, op2 %X\n", opcode, GET_INST(opcode), op1, op2); inst = GET_INST(opcode); VIS_PROFILE_END(PROF_VIRTUAL_DECODE); VIS_PROFILE_START(PROF_VIRTUAL_EXECUTE); switch(inst) { case MOVE_INST: *add2 = *add1; break; case ADDREF_INST: add_ref((datum *)add1); break; case RELEASE_INST: release_ref((datum *)add1); break; /* Temporarily commented out until multiple program support is finished case LOAD_INST: *add2 = (long)get_constant((char *)add1, -1); break; */ case CALL_INST: *((*stack)++) = (unsigned long)*pc; *((*stack)++) = RETURN_CODE_NORMAL; *pc = add1; break; /* Temporarily commented out until multiple program support is finished case CALLB_INST: //TODO: Needs to be made 100% correct DEBUGPRINTF("Calling builtin: %s\n", deflist[*add1].name); execute_def(deflist + *add1, entry, (datum **)registers, NULL); break;*/ case CALLP_INST: //TODO Implement me break; case CALLBP_INST: //TODO Implement me break; case RETURN_INST: switch(*(--(*stack))) { case RETURN_CODE_EXIT: execute_active = FALSE; break; case RETURN_CODE_IDLE: //TODO: Implement me break; case RETURN_CODE_NORMAL: *pc = (unsigned long *)*(--(*stack)); break; default: break; } break; case BRANCH_INST: *pc = add1; break; case BRANCHT_INST: if(*add2) *pc = add1; break; case BRANCHF_INST: if(!*add2) *pc = add1; break; case WAIT_INST: //TODO: Implement Me break; case ADD_INST: *add2 = *add1 + *add2; break; case SUB_INST: *add2 = *add1 - *add2; break; case SUBR_INST: *add2 = *add2 - *add1; break; case GREATER_INST: *add2 = *add1 > *add2; break; case LESSER_INST: *add2 = *add1 < *add2; break; default: break; } VIS_PROFILE_END(PROF_VIRTUAL_EXECUTE); } #ifdef ENABLE_PROFILING for(i = 0; i < NUM_PROFS; ++i) printf("%d:\t%f,\tcount: %d,\taverage: %f\n", i, (double)vis_profile_running_total[i], vis_profile_counts[i], ((double)vis_profile_running_total[i])/((double)vis_profile_counts[i])); #endif return 0; } void test_virtual() { // int i,j,k; program * prog = new_program(START_DEF_STORAGE, START_COMP_STORAGE); initpredefworkers(prog); init_sync_primitives(); init_datum_storage(); //TODO Uncomment me // init_global_storage(); execute_active = TRUE; /* for(i = MOVE_INST; i <= LESSER_INST; ++i) { for(j = 0; j < 0x10; ++j) { for(k = 0; k < 0x10; ++k) { DEBUGPRINTF("i: %X, j: %X, k: %X, OPC: %X\n", i, j, k, OPC(i, j, j, k, k)); } } }*/ virtual_processor(test_program, TRUE); } DWORD WINAPI worker_thread(LPVOID param) { queue_entry aworker; int temp_queue_len; while(execute_active) { VIS_PROFILE_START(PROF_WORKER_THREAD); #ifdef NINTENDO_DS if(irq_queue_count > 0) run_queued_irqs(); #endif //DEBUGPUTS("Before WaitForSingleObect\n"); /*VIS_EnterCriticalSection(worker_queue_lock); temp_queue_len = queue_len; VIS_LeaveCriticalSection(worker_queue_lock);*/ //DEBUGPUTS("After WaitForSingleObject\n"); aworker = get_queue(); //DEBUGPUTS("After get_queue()\n"); //while(execute_active && aworker.worker_num < 0)//temp_queue_len == 0 && execute_active) //{ // VIS_WaitEvent(queue_add_event); // aworker = get_queue(); /*#if COMPILE_THREADS > 0 #ifdef WIN32 Sleep(0); #else sleep(0); #endif #endif VIS_EnterCriticalSection(worker_queue_lock); temp_queue_len = queue_len; VIS_LeaveCriticalSection(worker_queue_lock);*/ //} if(aworker.worker_num >= 0) { //DEBUGPUTS("Before EnterCriticalSection\n"); /* VIS_EnterCriticalSection(worker_queue_lock); if(queue_len > 0) { DEBUGPUTS("SetEvent\n"); VIS_SetEvent(queue_add_event); } VIS_LeaveCriticalSection(worker_queue_lock);*/ DEBUGPRINTF( "\nExecuting: %s<%d>, Instance: %X\n", aworker.instance->def->implement_func->workerlist[aworker.worker_num].name,aworker.worker_num,aworker.instance); if(process_worker(aworker) == 0) { //worker_complete(aworker); cleanup_check(aworker); //DEBUGPUTS("After cleanup_check\n"); } } VIS_PROFILE_END(PROF_WORKER_THREAD); } VIS_SetEvent(queue_add_event); return 0; } int set_comp_room(datum ** params, int room_index, queue_entry * entry, program * prog) { int i; char * data; //DEBUGPRINTF("params[0]->ref_count: %d\n", params[0]->ref_count); params[0] = copy_datum(params[0], 0); data = ((char *)(params[0]->c.generic.data) + (int)params[0]->company->room_list[room_index].set_func); DEBUGPRINTF("Set comp room: c.generic.data = %X, +get_func = %X\n", params[0]->c.generic.data, data); //TODO: input conversion switch(params[0]->company->room_list[room_index].get_func_type) { case ROOM_BYTE: *data = params[1]->c.integers.num_a; release_ref(params[1]); break; case ROOM_SHORT: *((short *)data) = params[1]->c.integers.num_a; release_ref(params[1]); break; case ROOM_LONG: *((long *)data) = params[1]->c.integers.num_a; release_ref(params[1]); break; case ROOM_SINGLE: *((float *)data) = params[1]->c.real; release_ref(params[1]); break; case ROOM_DOUBLE: *((double *)data) = params[1]->c.real; release_ref(params[1]); break; case ROOM_VIS_REF: release_ref(*((datum **)data)); *((datum **)data) = params[1]; break; case ROOM_CSTRING: //not implemented case ROOM_CSTRING_STRUCT: case ROOM_PSTRING: case ROOM_PSTRING_STRUCT: case ROOM_WORKER://not implemented case ROOM_VIS_OBJECT://not implemented default: release_ref(params[0]); release_ref(params[1]); params[0] = params[1] = NULL; puts("unimplemented company room type\n"); break; } return 0; } int set_comp_room_by_name(datum ** company, char * name, int * room_index_ret, queue_entry * entry, program * prog) { int i; for (i = 0; i < company[0]->company->num_rooms; ++i) if(!strcmp(name,company[0]->company->room_list[i].name)) { if(room_index_ret) *room_index_ret = i; return set_comp_room(company, i, entry, prog); } if(room_index_ret) *room_index_ret = -1; return -1; } int get_comp_room(datum ** company, int room_index, queue_entry * entry, program * prog) { int i; datum * out; queue_entry empty; char * data = ((char *)(company[0]->c.generic.data) + (int)company[0]->company->room_list[room_index].get_func); company[1] = NULL; DEBUGPRINTF("Get comp room: c.generic.data = %X, +get_func = %X\n", company[0]->c.generic.data, data); switch(company[0]->company->room_list[room_index].get_func_type) { case ROOM_BYTE: out = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, prog); out->c.integers.num_a = *data; break; case ROOM_SHORT: out = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, prog); out->c.integers.num_a = *((short *)data); break; case ROOM_LONG: out = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, prog); out->c.integers.num_a = *((long *)data); break; case ROOM_SINGLE: out = new_datum(BUILTIN_TYPE_REAL, 3, 0, prog); out->c.real = *((float *)data); break; case ROOM_DOUBLE: out = new_datum(BUILTIN_TYPE_REAL, 3, 0, prog); out->c.real = *((double *)data); break; case ROOM_CSTRING: data = *((char **)data); case ROOM_CSTRING_STRUCT: out = new_datum(BUILTIN_TYPE_STRING, 1, strlen(data)+1, prog); strcpy(out->c.generic.data, data); break; case ROOM_PSTRING: data = *((char **)data); case ROOM_PSTRING_STRUCT: out = new_datum(BUILTIN_TYPE_STRING, 1, *((unsigned char *)data), prog); memcpy(out->c.generic.data, data, *((unsigned char *)data)); ((char *)out->c.generic.data)[*((unsigned char *)data)] = '\0'; break; case ROOM_VIS_REF: out = add_ref(*((datum **)data)); if(!out) { company[1] = company[0]; company[0] = NULL; } break; case ROOM_WORKER: if(entry) return execute_def((worker_def *)(company[0]->company->room_list[room_index].get_func), *entry, company, sub_callback); else { empty.instance = NULL; empty.worker_num = -1; return execute_def((worker_def *)(company[0]->company->room_list[room_index].get_func), empty, company, sub_callback); } case ROOM_VIS_OBJECT://not implemented default: out = NULL; puts("unimplemented company room type\n"); break; } release_ref(company[0]); company[0] = out; return 0; } int get_comp_room_by_name(datum ** company, char * name, int * room_index_ret, queue_entry * entry, program * prog) { int i; for (i = 0; i < company[0]->company->num_rooms; ++i) if(!strcmp(name,company[0]->company->room_list[i].name)) { if(room_index_ret) *room_index_ret = i; return get_comp_room(company, i, entry, prog); } if(room_index_ret) *room_index_ret = -1; return -1; } datum * literal_string(char * value, int len, program * prog) { char literalchar; BOOL literal; int i, bufpos, lenstr; datum * returnval; if(len < 0) { len = strlen(value); } literal = FALSE; lenstr = 0; for(i = 0; i < len; ++i) if(literal) literal = FALSE; else { ++lenstr; if(value[i] == '\\') literal = TRUE; } //DEBUGPRINTF("Allocating %d bytes for string constant\n", lenstr+1); returnval = new_datum(BUILTIN_TYPE_STRING, 1, lenstr+1, prog); bufpos = 0; for(i = 0; i < len; ++i) { if(literal) { literal = FALSE; switch(value[i]) { case 'n': //newline literalchar = '\n'; break; case 'r': //carriage return literalchar = '\r'; break; case 't': // tab literalchar = '\t'; break; case '0': //NULL literalchar = '\0'; break; default: literalchar = value[i]; break; } ((char *)returnval->c.generic.data)[bufpos++] = literalchar; } else { if(value[i] == '\\') literal = TRUE; else { ((char *)returnval->c.generic.data)[bufpos++] = value[i]; } } } //DEBUGPRINTF("bufpos: %d\n", bufpos); ((char *)returnval->c.generic.data)[bufpos] = '\0'; DEBUGPUTS("Constant Type: String\n"); return returnval; } datum * get_constant(char * value, int len, program * prog) { datum * params[2]; datum * returnval; int i = 0,bufpos; int start; int lenstr; int leftcurly; int dotcount = 0; char literalchar; unsigned short const_type = ANY_TYPE; BOOL literal; if((len == 3 && memcmp(value, "Yes", len) == 0) || (len < 0 && strcmp(value, "Yes") == 0)) { DEBUGPUTS("Constnat: Yes\n"); returnval = new_datum(BUILTIN_TYPE_YESNO, 2, 0, prog); returnval->c.integers.num_a = 1; DEBUGPRINTF("Company: %s, integers.num_a: %d\n", returnval->company->name, returnval->c.integers.num_a); return returnval; } else if((len == 2 && memcmp(value, "No", len) == 0) || (len < 0 && strcmp(value, "No") == 0)) { DEBUGPUTS("Constant: No\n"); returnval = new_datum(BUILTIN_TYPE_YESNO, 2, 0, prog); returnval->c.integers.num_a = 0; DEBUGPRINTF("Company: %s, integers.num_a: %d\n", returnval->company->name, returnval->c.integers.num_a); return returnval; } if(value[0] == '{') { DEBUGPUTS("Constant type: List"); params[0] = create_list(prog); i = start = 1; literal = FALSE; leftcurly = 0; for(;value[i] != 0 && (len < 0 || i < len); ++i) { if(literal) literal = FALSE; else { if(value[i] == '\\') literal = TRUE; else if(value[i] == '}') if(leftcurly) --leftcurly; else break; else if(value[i] == '{') ++leftcurly; else if(value[i] == ',' && !leftcurly) { params[1] = get_constant(value+start, i-start, prog); vis_list_append(params, NULL); start = i+1; } } } params[1]= get_constant(value+start, i-start, prog); vis_list_append(params, NULL); returnval = params[0]; } else if(value[0] == '"') { if(len < 0) { len = strlen(value); } len -= 2; returnval = literal_string(value+1, len, prog); } else { while(value[i] != 0 && (len < 0 || i < len)) { if(value[i] >= '0' && value[i] <= '9') { if(const_type == ANY_TYPE) const_type = BUILTIN_TYPE_WHOLE; } else if(value[i] == '.') { if(dotcount) { const_type = BUILTIN_TYPE_STRING; } else { ++dotcount; if(const_type == BUILTIN_TYPE_WHOLE) const_type = BUILTIN_TYPE_REAL; } } else { //DEBUGPRINTF("Current character: %c resulted in String\n", value[i]); const_type = BUILTIN_TYPE_STRING; break; } ++i; } if(const_type == BUILTIN_TYPE_WHOLE) { returnval = new_datum(const_type, 2, 0, prog); returnval->c.integers.num_a = atol(value); DEBUGPUTS("Constant Type: Whole Number\n"); } else if(const_type == BUILTIN_TYPE_REAL) { returnval = new_datum(const_type, 3, 0, prog); returnval->c.real = atof(value); DEBUGPUTS("Constant Type: Real Number\n"); } else { /* literal = FALSE; lenstr = 0; for(i = 0; (i < len || len < 0) && value[i] != 0; ++i) if(literal) literal = FALSE; else { ++lenstr; if(value[i] == '\\') literal = TRUE; } DEBUGPRINTF("Allocating %d bytes for string constant\n", lenstr+1); returnval = new_datum(BUILTIN_TYPE_STRING, 1, lenstr+1, prog); bufpos = 0; for(i = 0; (i < len || len < 0) && value[i] != 0; ++i) { DEBUGPRINTF("bufpos: %d\n", bufpos); if(literal) { literal = FALSE; switch(value[i]) { case 'n': //newline literalchar = '\n'; break; case 'r': //carriage return literalchar = '\r'; break; case 't': // tab literalchar = '\t'; break; case '0': //NULL literalchar = '\0'; break; default: literalchar = value[i]; break; } ((char *)returnval->c.generic.data)[bufpos++] = literalchar; } else { if(value[i] == '\\') literal = TRUE; else { ((char *)returnval->c.generic.data)[bufpos++] = value[i]; } } } DEBUGPRINTF("bufpos: %d\n", bufpos); ((char *)returnval->c.generic.data)[bufpos] = '\0'; DEBUGPUTS("Constant Type: String\n"); */ returnval = literal_string(value, len, prog); } } return returnval; } int execute_def(worker_def * process_def, queue_entry worker_entry, datum ** params, instance_callback callback) { return execute_def_type(process_def, worker_entry, params, callback, NULL, WORKER); } int execute_def_data(worker_def * process_def, queue_entry worker_entry, datum ** params, instance_callback callback, void * data) { return execute_def_type(process_def, worker_entry, params, callback, data, WORKER); } int execute_def_type(worker_def * process_def, queue_entry worker_entry, datum ** params, instance_callback callback, void * data, int type) { int returnval, i; worker_instance * stack_instance; worker_def *temp_def, *converter; worker_def *parent_def = worker_entry.instance->def; unsigned short magic_cache_type; #ifdef USER_PROFILE LARGE_INTEGER start, end, duration; #endif VIS_PROFILE_START(PROF_PREP_MAGIC); if((process_def->type & TYPE_MASK) == MAGIC_TYPE) { DEBUGPRINTF( "Magic method: %s\n", process_def->name); if(!params || !params[0]) { ERRORPRINTF("Error: null first parmeter or null parameter array for worker %s\n", process_def->name); print_stack_trace(worker_entry.instance); execute_active = FALSE; return -1; } VIS_EnterCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); temp_def = parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_implement; magic_cache_type = parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_type; VIS_LeaveCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); if(!temp_def || magic_cache_type != params[0]->company->type_id) { DEBUGPRINTF("Finding method %s with %d inputs for type %s(%d)\n", process_def->name, process_def->num_inputs, params[0]->company->name, params[0]->company->type_id); temp_def = find_method(params[0]->company->type_id,process_def->name, process_def->num_inputs, process_def->program); if(!temp_def) { for(i = 1; i < process_def->program->num_companies; ++i) { temp_def = find_method(i,process_def->name, process_def->num_inputs, process_def->program); if(temp_def) { converter = find_converter_method(temp_def->input_types[0], params[0]->company->type_id, process_def->program); if(converter) { ((worker_impl)converter->implement_func)(params, &worker_entry); break; } else { //DEBUGPRINTF("Error: Needed conversion from %s to %s for input %d of %s\n", params[0]->company->name, process_def->program->companylist[temp_def->input_types[0]].name, 0, temp_def->name); //printf("Warning: Needed conversion from %s to %s for input %d of %s for loose method call\n", params[0]->company->name, process_def->program->companylist[temp_def->input_types[0]].name, 0, temp_def->name); temp_def = NULL; } } } } if(temp_def) { VIS_EnterCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_implement = temp_def; parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_type = temp_def->input_types[0]; VIS_LeaveCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); } else { ERRORPRINTF("Error: Company %s doesn't implement worker %s. It implements the following:\n", params[0]->company->name, process_def->name); for(i = 0; i < params[0]->company->num_methods; ++i) { ERRORPRINTF("%s\n", params[0]->company->methodlist[i]->name); } print_stack_trace(worker_entry.instance); } } process_def = temp_def; } VIS_PROFILE_END(PROF_PREP_MAGIC); if(!process_def) { //DEBUGPUTS("Invalid def\n"); VIS_PROFILE_END(PROF_EXECUTE_WORKER); execute_active = FALSE; return -2; } VIS_PROFILE_START(PROF_CONVERT_INPUTS); for(i = 0; i < process_def->num_inputs; ++i) { DEBUGPRINTF("params[%d] = %X\n", i, params[i]); if(process_def->input_types[i] != ANY_TYPE && process_def->input_types[i] != params[i]->company->type_id) { DEBUGPRINTF("Input %d needs conversion from %d to %d\n", i, params[i]->company->type_id, process_def->input_types[i]); converter = find_converter_method(process_def->input_types[i], params[i]->company->type_id, process_def->program); if(!converter) { if(worker_entry.instance) { ERRORPRINTF("Error: Needed conversion from %s to %s for input %d of %s in worker %s\n", params[i]->company->name, process_def->program->companylist[process_def->input_types[i]].name, i, process_def->name, worker_entry.instance->def->name); print_stack_trace(worker_entry.instance); } else { DEBUGPRINTF("Error: Needed conversion from %s to %s for input %d of %s\n", params[i]->company->name, process_def->program->companylist[process_def->input_types[i]].name, i, process_def->name); printf("Error: Needed conversion from %s to %s for input %d of %s", params[i]->company->name, process_def->program->companylist[process_def->input_types[i]].name, i, process_def->name); } execute_active = FALSE; VIS_PROFILE_END(PROF_PROCESS_WORKER); return -3; } ((worker_impl)(converter->implement_func))(params+i, &worker_entry); } } VIS_PROFILE_END(PROF_CONVERT_INPUTS); if(process_def->type & USER_FLAG) { VIS_PROFILE_START(PROF_EXECUTE_CUSTOM); // init_custom_worker_type(worker_entry.worker_num, worker_entry.instance, process_def, callback, data, params, type); VIS_PROFILE_END(PROF_EXECUTE_CUSTOM); VIS_PROFILE_END(PROF_PROCESS_WORKER); VIS_PROFILE_END(PROF_EXECUTE_WORKER); return 1; } else { VIS_PROFILE_START(PROF_EXECUTE_BUILTIN); //DEBUGPRINTF("%s: before deflist[%d].implement_func: %X. vis_append: %X vis_print: %X\n",def->implement_func->workerlist[aworker].name, def->implement_func->workerlist[aworker].value_index, (int)deflist[def->implement_func->workerlist[aworker].value_index].implement_func, (int)vis_append, (int)vis_print); #ifdef USER_PROFILE QueryPerformanceCounter(&start); #endif returnval = ((worker_impl)(process_def->implement_func))(params, &worker_entry); #ifdef USER_PROFILE if(!returnval) { QueryPerformanceCounter(&end); duration.QuadPart = end.QuadPart - start.QuadPart; VIS_EnterCriticalSection(process_def->lock); process_def->total.QuadPart += duration.QuadPart; ++process_def->count; if(duration.QuadPart > process_def->worst.QuadPart) process_def->worst.QuadPart = duration.QuadPart; VIS_LeaveCriticalSection(process_def->lock); } #endif //DEBUGPUTS("Builtin worker returned\n"); VIS_PROFILE_END(PROF_EXECUTE_BUILTIN); return returnval; } } void wait_callback(worker_instance * caller_instance, int caller_workerenum, worker_instance * done_instance, void * data) { int i; def_done * done = (def_done *)data; //DEBUGPUTS("begin wait_callback\n"); for(i = 0; i < done_instance->def->num_outputs; ++i) done->params[i] = NULL; for(i = 0; i < done_instance->def->implement_func->num_workers; ++i) { if(done_instance->def->implement_func->workerlist[i].type == 4) { if(!(done->params[done_instance->def->implement_func->workerlist[i].io_num])) { done->params[done_instance->def->implement_func->workerlist[i].io_num] = done_instance->workerlist[i].value; done_instance->workerlist[i].value = NULL; } } } //DEBUGPUTS("Before EnterCritical\n"); VIS_EnterCriticalSection(done->lock); done->done_flag = TRUE; VIS_LeaveCriticalSection(done->lock); //DEBUGPUTS("After EnterCritical\n"); } BOOL execute_def_wait(worker_def * def, datum ** params) { int val; def_done done; queue_entry entry; entry.worker_num = 0; entry.instance = NULL; VIS_InitializeCriticalSection(done.lock); done.done_flag = FALSE; done.params = params; val = execute_def_data(def, entry, params, wait_callback, &done); if(val == 0) return TRUE; else if (val < 0) return FALSE; while(1) { VIS_EnterCriticalSection(done.lock); if(done.done_flag) { VIS_DeleteCriticalSection(done.lock); break; } VIS_LeaveCriticalSection(done.lock); #if COMPILE_THREADS > 1 #ifdef WIN32 Sleep(0); #else sleep(0); #endif #endif } return TRUE; } int process_worker(queue_entry worker_entry) { //datum * paramstore[32]; datum ** params;// = paramstore; int i, j, start=0; global_store * store; char * varname; datum * varname_dat; datum * tempvalindex, *todelete; int got_params=0; int aworker = worker_entry.worker_num; worker_instance * instance = worker_entry.instance; worker_def * def = instance->def; worker_def * process_def; worker_def * temp_def; worker_def * converter; int returnval = 0; short const_type; char * last; VIS_PROFILE_START(PROF_PROCESS_WORKER); DEBUGPRINTF( "Processing worker %d with %d inputs and %d outputs\n", aworker,def->implement_func->workerlist[aworker].num_inputs, def->implement_func->workerlist[aworker].num_outputs); /*VIS_EnterCriticalSection(instance->workerlist[aworker].worker_lock); for(i = 0; i < def->implement_func->workerlist[aworker].num_inputs; ++i) { params[i] = instance->workerlist[aworker].params[i+1]; DEBUGPRINTF("params[%d] = %X\n", i, params[i]); instance->workerlist[aworker].params[i+1] = NULL; }*/ if(def->implement_func->workerlist[aworker].null_input) { //DEBUGPUTS("About to call release_ref\n"); release_ref(instance->workerlist[aworker].params[0]); instance->workerlist[aworker].params[0] = NULL; } //VIS_LeaveCriticalSection(instance->workerlist[aworker].worker_lock); //DEBUGPRINTF("Param check complete. returnval: %d, start: %d\n", returnval, start); params = instance->workerlist[aworker].params+1; if(def->implement_func->workerlist[aworker].type == WORKER || def->implement_func->workerlist[aworker].type == TAIL_RECURSE || def->implement_func->workerlist[aworker].type == TAIL_CALL)//Worker { VIS_PROFILE_START(PROF_EXECUTE_WORKER); //DEBUGPUTS("Worker\n"); process_def = (worker_def *)(def->implement_func->workerlist[aworker].value_index); //DEBUGPUTS("Got process_def\n"); DEBUGPRINTF("process_def->type: %X, type & TYPE_MASK: %X\n", process_def->type, (process_def->type & TYPE_MASK)); returnval = execute_def_type(process_def, worker_entry, params, sub_callback, NULL, def->implement_func->workerlist[aworker].type); DEBUGPRINTF("execute_def returned %d\n", returnval); if(returnval != 0) { VIS_PROFILE_END(PROF_PROCESS_WORKER); VIS_PROFILE_END(PROF_EXECUTE_WORKER); return returnval; } //DEBUGPRINTF("params[0] after execute_def: %X\n", params[0]); //DEBUGPUTS("Before process_outputs\n"); process_outputs(params, aworker, instance); //DEBUGPUTS("After process_outputs\n"); VIS_PROFILE_END(PROF_EXECUTE_WORKER); } else if(def->implement_func->workerlist[aworker].type == GET_GLOBAL) { varname = def->implement_func->workerlist[aworker].name + def->implement_func->workerlist[aworker].io_num; varname_dat = make_string(varname, -1, def->program); if(def->implement_func->workerlist[aworker].value_index < 0) { for(i = 0; i < instance->trans->num_stores; ++i) { VIS_EnterCriticalSection(instance->trans->stores[i].lock); params[0] = add_ref(instance->trans->stores[i].instance_data); VIS_LeaveCriticalSection(instance->trans->stores[i].lock); params[1] = add_ref(varname_dat); vis_dict_index(params, NULL); if(params[0]) { def->implement_func->workerlist[aworker].value_index = i; break; } } if(def->implement_func->workerlist[aworker].value_index < 0) { printf("Error: Variable %s not found in any global stores used by worker %s\n", varname, def->name); DEBUGPRINTF("Error: Variable %s not found in any global stores used by worker %s\n", varname, def->name); execute_active = FALSE; return -1; } } else { VIS_EnterCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); params[0] = add_ref(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].instance_data); VIS_LeaveCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); params[1] = varname_dat; vis_dict_index(params, NULL); if(!params[0]) { printf("Error: Global variable %s not found in worker %s\n", def->implement_func->workerlist[aworker].name, def->name); DEBUGPRINTF("Error: Global variable %s not found in worker %s\n", def->implement_func->workerlist[aworker].name, def->name); execute_active = FALSE; return -1; } } process_outputs(params, aworker, instance); } else if(def->implement_func->workerlist[aworker].type == SET_GLOBAL) { varname = def->implement_func->workerlist[aworker].name + def->implement_func->workerlist[aworker].io_num; varname_dat = make_string(varname, -1, def->program); params[2] = params[0]; params[1] = varname_dat; VIS_EnterCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); //no add_ref here because we'll be replacing instance_data with the result of vis_dict set params[0] = instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].instance_data; vis_dict_set(params, NULL); instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].instance_data = params[0]; VIS_LeaveCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); //no outputs to process } else if(def->implement_func->workerlist[aworker].type == GET_COMP) { returnval = get_comp_room_by_name(params, def->implement_func->workerlist[aworker].name, NULL, &worker_entry, def->program); if(returnval) return returnval; process_outputs(params, aworker, instance); } else if(def->implement_func->workerlist[aworker].type == SET_COMP) { returnval = set_comp_room_by_name(params, def->implement_func->workerlist[aworker].name, NULL, &worker_entry, def->program); if(returnval) return returnval; process_outputs(params, aworker, instance); } else//Variable { VIS_PROFILE_START(PROF_EXECUTE_OTHER); if(def->implement_func->workerlist[aworker].num_inputs > 0 || def->implement_func->workerlist[aworker].type == INPUT) //Is this a Room or a constant? { todelete = NULL; VIS_EnterCriticalSection(instance->workerlist[aworker].worker_lock); if(def->implement_func->workerlist[aworker].type == OUTPUT) { todelete = instance->workerlist[aworker].value; instance->workerlist[aworker].value = params[0]; DEBUGPRINTF("Setting room/output at pos %d to %X in instance %X\n", aworker, params[0], instance); } //tempvalindex = instance->workerlist[aworker].value; VIS_LeaveCriticalSection(instance->workerlist[aworker].worker_lock); if(def->implement_func->workerlist[aworker].type == INPUT) { params[0] = instance->workerlist[aworker].value; instance->workerlist[aworker].value = NULL; } if(todelete) release_ref(todelete); if(def->implement_func->workerlist[aworker].num_outputs) { //add_ref(tempvalindex); process_outputs(params/*&tempvalindex*/, aworker, instance); } } else { //Hmm, do I potentially need another lock here? /*if(!(instance->def->implement_func->workerlist[aworker].value_index)) { instance->def->implement_func->workerlist[aworker].value_index = (int)(tempvalindex=get_constant(def->implement_func->workerlist[aworker].name,-1));//(int)tempvalindex; } else*/ tempvalindex = (datum *)instance->def->implement_func->workerlist[aworker].value_index; add_ref(tempvalindex); process_outputs(&tempvalindex, aworker, instance); } VIS_PROFILE_END(PROF_EXECUTE_OTHER); } VIS_PROFILE_END(PROF_PROCESS_WORKER); return returnval; } #define OPT_RESULT 0 #define OPT_CUST_RESULT 0x10000000 #define OPT_CONST 0x20000000 #define OPT_INPUT 0x30000000 int find_input_worker(custom_worker * cust, int aworker, int input, int *ret_output) { int o, p, wire_count; int out_worker; o = cust->workerlist[aworker].wire_up_lookup; wire_count = 0; while(cust->wirelist[p=cust->workers_to_wires_up[o]].end_worker == aworker && p >= 0) { if(cust->wirelist[p].input_num == input) { ++wire_count; out_worker = cust->wirelist[p].start_worker; DEBUGPRINTF("Input %d attached to %s(%d)\n", input, cust->workerlist[out_worker].name, out_worker); if(ret_output) *ret_output = cust->wirelist[p].output_num; } ++o; } DEBUGPRINTF("wire_count: %d\n", wire_count); if(wire_count == 1) return out_worker; return -1; } int make_input_code(custom_worker * cust, BOOL * in_opt, int * pos_in_opt, int source_worker, int output_num, int index, opt_entry * opts, int * branch_flags, opt_entry ** branch_refs, int input_num, program * prog) { /*if(in_opt[source_worker]) { if(prog->deflist[cust->workerlist[source_worker].value_index].type & USER_FLAG) { return OPT_CUST_RESULT | ((pos_in_opt[source_worker] & 0xFFFF) << 8) | (output_num & 0xFF); } else { if(strcmp(prog->deflist[cust->workerlist[source_worker].value_index].name, "If") == 0) { if(output_num == 0) { branch_flags[index] = 1; if(opts[pos_in_opt[source_worker]].branch1 <= index) opts[pos_in_opt[source_worker]].branch1 = index+1; } else { branch_flags[index] = 2; if(opts[pos_in_opt[source_worker]].branch2 <= index) opts[pos_in_opt[source_worker]].branch2 = index+1; } branch_refs[index] = opts + pos_in_opt[source_worker]; } else if(branch_flags[pos_in_opt[source_worker]]) { if(branch_flags[pos_in_opt[source_worker]] == 1) { branch_refs[pos_in_opt[source_worker]]->branch1 = index + 1; branch_flags[index] = 1; } else { branch_refs[pos_in_opt[source_worker]]->branch1 = index + 2; branch_flags[index] = 2; } branch_refs[index] = branch_refs[pos_in_opt[source_worker]]; } else branch_flags[index] = 0; if(input_num >= 0) ++opts[pos_in_opt[source_worker]].output_refs[output_num]; DEBUGPRINTF("OPT_RESULT: opt_num: %d, output_num: %d\n", pos_in_opt[source_worker], output_num); return OPT_RESULT | ((pos_in_opt[source_worker] & 0xFFFF) << 8) | (output_num & 0xFF); } } else if(cust->workerlist[source_worker].type == CONSTANT) { branch_flags[index] = 0; DEBUGPRINTF("OPT_CONST: %d\n", source_worker); return OPT_CONST | source_worker; } else if(cust->workerlist[source_worker].type == INPUT) { branch_flags[index] = 0; DEBUGPRINTF("OPT_INPUT: %d\n", cust->workerlist[source_worker].io_num); return OPT_INPUT | cust->workerlist[source_worker].io_num; }*/ return -1; } void optimize(worker_def * def) { /* int i,j,k,m,o,p; int * const_in; int num_entries = 0; int aworker; int adjust; int source_worker; int source_output; int source_null; int null_output; int wire_count; int * input_data; int current_null; int cust_result_count; int new_start; custom_worker * cust = def->implement_func; int start_current, end_current, new_current; worker_def * deflist = def->program->deflist; opt_entry * output = malloc(sizeof(opt_entry) * def->implement_func->num_workers); BOOL * in_opt = malloc(sizeof(BOOL) * cust->num_workers); int * branch_flags = malloc(sizeof(int) * cust->num_workers); opt_entry ** branch_refs = malloc(sizeof(int) * cust->num_workers); //BOOL * real_in_opt = malloc(sizeof(BOOL) * cust->num_workers); int * pos_in_opt = malloc(sizeof(int) * cust->num_workers); DEBUGPRINTF("deflist: %X\n", deflist); for(i = 0; i < cust->num_workers; ++i) { branch_flags[i] = 0; DEBUGPRINTF("%d: No input pass\n", i); DEBUGPRINTF("Examining: %s\n", cust->workerlist[i].name); if(cust->workerlist[i].num_inputs == 0 && !cust->workerlist[i].null_input && cust->workerlist[i].type == WORKER) { output[num_entries].def = deflist + cust->workerlist[i].value_index; DEBUGPRINTF("Set output[%d].def = %X\n", num_entries, output[num_entries].def); DEBUGPRINTF("opt: %d is %s\n\n", num_entries, cust->workerlist[i].name); output[num_entries].original_pos = i; output[num_entries].input_data = NULL; if(cust->workerlist[i].num_outputs) { output[num_entries].output_refs = malloc(sizeof(int)*cust->workerlist[i].num_outputs); for(j = 0; j < cust->workerlist[i].num_outputs; ++j) output[num_entries].output_refs[j] = 0; } else output[num_entries].output_refs = NULL; output[num_entries].branch1 = output[num_entries].branch2 = -1; //if(!(deflist[cust->workerlist[i].value_index].type & USER_FLAG)) //{ in_opt[i] = TRUE; pos_in_opt[i] = num_entries; //} //real_in_opt[i] = TRUE; ++num_entries; } else { //real_in_opt[i] = FALSE; in_opt[i] = FALSE; } } start_current = num_entries; for(i = 0; i < cust->num_workers; ++i) { DEBUGPRINTF("%d: Second pass\n", i); if(cust->workerlist[i].num_inputs == 0 && !cust->workerlist[i].null_input) { j = cust->workerlist[i].wire_down_lookup; while(cust->wirelist[k=cust->workers_to_wires_down[j]].start_worker == i && k >= 0) { aworker = cust->wirelist[k].end_worker; if(!in_opt[aworker]) { DEBUGPRINTF("Examining: %s(%d)\n", cust->workerlist[aworker].name, aworker); if(cust->workerlist[i].null_input) adjust = 1; else adjust = 0; input_data = malloc(sizeof(int)* (cust->workerlist[aworker].num_inputs+adjust)); for(m = (0-adjust); m < cust->workerlist[aworker].num_inputs; ++m) { DEBUGPRINTF("Input: %d\n", m); source_worker = find_input_worker(cust, aworker, m, &source_output); DEBUGPRINTF("source_worker: %d\n", source_worker); if(source_worker == -1) break; source_worker = make_input_code(cust, in_opt, pos_in_opt, source_worker, source_output, num_entries, output, branch_flags, branch_refs, m, def->program); DEBUGPRINTF("input code: %X\n", source_worker); if(source_worker == -1) break; input_data[m+adjust] = source_worker; if(source_worker == -1) break; } if(source_worker == -1) free(input_data); else { if(cust->workerlist[aworker].type == OUTPUT) output[num_entries].def = NULL; else output[num_entries].def = deflist + cust->workerlist[aworker].value_index; DEBUGPRINTF("Set output[%d].def = %X\n", num_entries, output[num_entries].def); DEBUGPRINTF("opt: %d is %s\n\n", num_entries, cust->workerlist[aworker].name); output[num_entries].original_pos = aworker; output[num_entries].input_data = input_data; output[num_entries].null_inputs = adjust; output[num_entries].branch1 = output[num_entries].branch2 = -1; if(cust->workerlist[aworker].num_outputs) { output[num_entries].output_refs = malloc(sizeof(int)*cust->workerlist[aworker].num_outputs); for(m = 0; m < cust->workerlist[aworker].num_outputs; ++m) output[num_entries].output_refs[m] = 0; } else output[num_entries].output_refs = NULL; //if(cust->workerlist[aworker].type != OUTPUT && !(deflist[cust->workerlist[aworker].value_index].type & USER_FLAG)) //{ in_opt[aworker] = TRUE; pos_in_opt[aworker] = num_entries; //} //real_in_opt[aworker] = TRUE; ++num_entries; } } ++j; } } } DEBUGPUTS("Before While\n"); end_current = num_entries; while(start_current != end_current) { DEBUGPRINTF("start_current: %d, end_current: %d\n", start_current, end_current); new_start = num_entries; for(i = start_current; i < end_current; ++i) { DEBUGPRINTF("opt: %d, def: %X, name: %s\n", i, output[i].def, cust->workerlist[output[i].original_pos].name); j = cust->workerlist[output[i].original_pos].wire_down_lookup; DEBUGPRINTF("wire_down_lookup: %d\n", j); while(cust->wirelist[k=cust->workers_to_wires_down[j]].start_worker == output[i].original_pos && k >= 0) { DEBUGPRINTF("Wire %d is attached to worker %d output %d and worker %d input %d\n", k, cust->wirelist[k].start_worker, cust->wirelist[k].output_num, cust->wirelist[k].end_worker, cust->wirelist[k].input_num); aworker = cust->wirelist[k].end_worker; //FIXME: Only works if constant/input attached to only one destination if(cust->workerlist[aworker].type == CONSTANT || cust->workerlist[aworker].type == INPUT) { DEBUGPRINTF("Worker is of type %d, ", cust->workerlist[aworker].type); aworker = cust->wirelist[cust->workers_to_wires_down[cust->workerlist[aworker].wire_down_lookup]].end_worker; DEBUGPRINTF("reruting to worker %d\n", aworker); } if(!in_opt[aworker]) { DEBUGPRINTF("Examining: %s(%d)\n", cust->workerlist[aworker].name, aworker); if(cust->workerlist[i].null_input) adjust = 1; else adjust = 0; for(m = (0-adjust); m < cust->workerlist[aworker].num_inputs; ++m) { source_worker = find_input_worker(cust, aworker, m, &source_output); if(source_worker == -1) break; if(cust->workerlist[source_worker].null_input && cust->workerlist[source_worker].type != WORKER) ++adjust; } if(source_worker != -1) { current_null = 0; input_data = malloc(sizeof(int)* (cust->workerlist[aworker].num_inputs+adjust)); cust_result_count = 0; for(m = (cust->workerlist[i].null_input ? -1 : 0); m < cust->workerlist[aworker].num_inputs; ++m) { DEBUGPRINTF("Input: %d\n", m); source_worker = find_input_worker(cust, aworker, m, &source_output); if(cust->workerlist[source_worker].null_input && cust->workerlist[source_worker].type != WORKER) { source_null = find_input_worker(cust, source_worker, -1, &null_output); if(source_null == -1) { source_worker = -1; break; } source_null = make_input_code(cust, in_opt, pos_in_opt, source_null, null_output, num_entries, output, branch_flags, branch_refs,-2, def->program); if((source_null & 0xF0000000) == OPT_CUST_RESULT) ++cust_result_count; if(source_null == -1) { source_worker = -1; break; } input_data[current_null++] = source_null; } DEBUGPRINTF("source_worker: %d\n", source_worker); source_worker = make_input_code(cust, in_opt, pos_in_opt, source_worker, source_output, num_entries, output, branch_flags, branch_refs, m, def->program); if((source_worker & 0xF0000000) == OPT_CUST_RESULT) ++cust_result_count; DEBUGPRINTF("input code: %d\n", source_worker); if(cust_result_count >= (cust->workerlist[aworker].num_inputs + adjust)) source_worker = -1; if(source_worker == -1) break; input_data[m+adjust] = source_worker; } if(source_worker == -1) free(input_data); else { if(cust->workerlist[aworker].type == OUTPUT) output[num_entries].def = NULL; else output[num_entries].def = deflist + cust->workerlist[aworker].value_index; DEBUGPRINTF("Set output[%d].def = %X\n", num_entries, output[num_entries].def); DEBUGPRINTF("opt: %d is %s\n\n", num_entries, cust->workerlist[aworker].name); output[num_entries].original_pos = aworker; output[num_entries].input_data = input_data; output[num_entries].null_inputs = adjust; output[num_entries].branch1 = output[num_entries].branch2 = -1; if(cust->workerlist[aworker].num_outputs) { output[num_entries].output_refs = malloc(sizeof(int)*cust->workerlist[aworker].num_outputs); for(m = 0; m < cust->workerlist[aworker].num_outputs; ++m) output[num_entries].output_refs[m] = 0; } else output[num_entries].output_refs = NULL; //if(cust->workerlist[aworker].type != OUTPUT && !(deflist[cust->workerlist[aworker].value_index].type & USER_FLAG)) //{ in_opt[aworker] = TRUE; pos_in_opt[aworker] = num_entries; //} //real_in_opt[aworker] = TRUE; ++num_entries; } } } ++j; } } start_current = new_start; end_current = num_entries; } def->optimized = output; def->opt_count = num_entries; DEBUGPUTS("optimize done\n\n\n"); */ } void run_optimized(worker_instance * instance, datum ** params) { int i = 0,j,k; unsigned short output, opt_num; datum * this_params[32]; queue_entry entry; datum * val; BOOL skip; BOOL partial_flag; BOOL continue_flag; int count; int ready; int jump_from = -1; int jump_to = -1; int tmp, addnum; opt_entry * exec_list = instance->def->optimized; datum ** results = instance->opt_results;//malloc(sizeof(datum *) * instance->def->opt_count * 32); VIS_PROFILE_START(PROF_RUN_OPT); entry.instance = instance; for(i = 0; i < instance->def->opt_count; ++i) { VIS_PROFILE_START(PROF_OPT_LOOP); skip = FALSE; partial_flag = FALSE; continue_flag = FALSE; DEBUGPRINTF("\nPeparing exec_list[%d]\n", i); if(exec_list[i].def) { DEBUGPRINTF("Name: %s\n", exec_list[i].def->name); count = exec_list[i].def->num_inputs; } else count = 1; count += exec_list[i].null_inputs; //DEBUGPRINTF("Input count: %d\n", count); if(count && !exec_list[i].input_data) puts("Runtime Error: input data is NULL\n"); //DEBUGPRINTF("input_data: %X\n", exec_list[i].input_data); VIS_PROFILE_START(PROF_OPT_PREP_INPUT); for(j = 0; j < count; ++j) { val = NULL; continue_flag = FALSE; switch(exec_list[i].input_data[j] & 0xF0000000) { case OPT_RESULT: output = exec_list[i].input_data[j] & 0xFF; opt_num = (exec_list[i].input_data[j] >> 8)& 0xFFFF; DEBUGPRINTF("OPT_RESULT for input %d, opt_num: %d, output: %d\n", j, opt_num, output); val = results[(opt_num * 32) | output]; break; case OPT_CUST_RESULT: val = NULL; partial_flag = TRUE; continue_flag = TRUE; break; case OPT_INPUT: DEBUGPRINTF("OPT_INPUT for input %d\n", j); val = add_ref(params[exec_list[i].input_data[j] & 0xFF]); break; case OPT_CONST: DEBUGPRINTF("OPT_CONST for input %d\n", j); val = add_ref((datum *)(instance->def->implement_func->workerlist[exec_list[i].input_data[j] & 0xFFFFFF].value_index)); break; default: puts("Runtime Error: Invalid bytecode\n"); val = NULL; break; } if(!val && !continue_flag) { for(k = exec_list[i].null_inputs; k < j; ++k) release_ref(this_params[k]); skip = TRUE; break; } DEBUGPRINTF("this_params[%d] = %X\n", j, val); if(j >= exec_list[i].null_inputs) if(val) this_params[j] = /*add_ref(*/val/*)*/; else this_params[j] = NULL; } VIS_PROFILE_END(PROF_OPT_PREP_INPUT); if(!skip) { if(partial_flag) { VIS_PROFILE_START(PROF_PARTIAL_EXEC); ready = 0; for(j = exec_list[i].null_inputs; j < count; ++j) if(this_params[j]) { instance->workerlist[exec_list[i].original_pos].params[j-exec_list[i].null_inputs+1] = this_params[j]; ++ready; } if(instance->def->implement_func->workerlist[exec_list[i].original_pos].null_input && this_params[exec_list[i].null_inputs-1]) ++ready; DEBUGPRINTF("ready: %d\n", ready); skip = TRUE; VIS_EnterCriticalSection(instance->workerlist[exec_list[i].original_pos].worker_lock); instance->workerlist[exec_list[i].original_pos].ready_count += ready; if(instance->workerlist[exec_list[i].original_pos].ready_count >= (exec_list[i].def->num_inputs + (instance->def->implement_func->workerlist[exec_list[i].original_pos].null_input ? 1 : 0))) { skip = FALSE; instance->workerlist[exec_list[i].original_pos].ready_count = 0; } DEBUGPRINTF("ready_count: %d\n", instance->workerlist[exec_list[i].original_pos].ready_count); VIS_LeaveCriticalSection(instance->workerlist[exec_list[i].original_pos].worker_lock); if(!skip) add_queue(exec_list[i].original_pos, instance); VIS_PROFILE_END(PROF_PARTIAL_EXEC); } else if(exec_list[i].def) { VIS_PROFILE_START(PROF_FULL_EXEC); DEBUGPRINTF("opt_exec: %s(%d)\n", exec_list[i].def->name, exec_list[i].original_pos); entry.worker_num = exec_list[i].original_pos; if(exec_list[i].def->type & USER_FLAG) { VIS_PROFILE_START(PROF_OPT_EXEC_USER); instance->workerlist[exec_list[i].original_pos].params[0] = NULL; memcpy(instance->workerlist[exec_list[i].original_pos].params+1, this_params + exec_list[i].null_inputs, sizeof(datum *) * exec_list[i].def->num_inputs); add_queue(exec_list[i].original_pos, instance); VIS_PROFILE_END(PROF_OPT_EXEC_USER); } else { VIS_PROFILE_START(PROF_OPT_EXEC_BUILT); if(execute_def(exec_list[i].def, entry, this_params + exec_list[i].null_inputs, sub_callback) == 0) { DEBUGPUTS("Exectuted with reslts\n"); if(exec_list[i].output_refs) { for(j = exec_list[i].null_inputs; j < (exec_list[i].def->num_outputs+exec_list[i].null_inputs); ++j) { DEBUGPRINTF("output_refs[%d] = %d\n", j-exec_list[i].null_inputs, exec_list[i].output_refs[j-exec_list[i].null_inputs]); if(!exec_list[i].output_refs[j-exec_list[i].null_inputs]) release_ref(this_params[j]); else if(exec_list[i].output_refs[j-exec_list[i].null_inputs] > 1) { /*DEBUGPRINTF("multi_add_ref(%X): %d\n", this_params[j], exec_list[i].output_refs[j-exec_list[i].null_inputs]-1); tmp = (int)(&(this_params[j]->ref_count)); addnum = exec_list[i].output_refs[j-exec_list[i].null_inputs]-1; __asm { mov ebx, tmp mov eax, addnum lock xadd dword ptr [ebx], eax }*/ VIS_EnterCriticalSection(this_params[j]->lock); this_params[j]->ref_count += exec_list[i].output_refs[j-exec_list[i].null_inputs]-1; VIS_LeaveCriticalSection(this_params[j]->lock); } } memcpy(results + i*32, this_params + exec_list[i].null_inputs, sizeof(datum *) * exec_list[i].def->num_outputs); if(exec_list[i].branch1 >= 0) { if(this_params[exec_list[i].null_inputs]) { jump_from = exec_list[i].branch1; jump_to = exec_list[i].branch2; } else { i = exec_list[i].branch1-1; } } } } /*else { for(j = exec_list[i].null_inputs; j < (exec_list[i].def->num_outputs + exec_list[i].null_inputs); ++j) results[(i*32)|j] = NULL; }*/ VIS_PROFILE_END(PROF_OPT_EXEC_BUILT); } VIS_PROFILE_END(PROF_FULL_EXEC); DEBUGPUTS("Executed\n"); } else instance->workerlist[exec_list[i].original_pos].value = this_params[exec_list[i].null_inputs]; } else { DEBUGPUTS("Skipped\n"); if(exec_list[i].def) { for(j = 0; j < exec_list[i].def->num_outputs; ++j) results[(i*32)|j] = NULL; } } if(jump_from >= 0 && (i+1) == jump_from) { i = jump_to-1; jump_from = -1; } VIS_PROFILE_END(PROF_OPT_LOOP); } DEBUGPUTS("run_optimized calling cleanup_check\n"); for(i = 0; i < instance->def->num_inputs; ++i) release_ref(params[i]); cleanup_check(entry); VIS_PROFILE_END(PROF_RUN_OPT); } int vis_print(datum ** inputlist, queue_entry * worker_entry) { int result; #ifdef CONSOLE puts((char *)inputlist[0]->c.generic.data); #else MessageBox(NULL, (char *)inputlist[0]->c.generic.data, "Visuality Output", MB_OK); #endif result = 1; release_ref(inputlist[0]); inputlist[0] = new_datum(BUILTIN_TYPE_YESNO, 2, 0, worker_entry->instance->def->program); //No one else knows about this new datum yet so we can skip getting a lock datum_set_yesno(inputlist[0], result); return 0; } int vis_end(datum ** inputlist, queue_entry * worker_entry) { // fprintf(outfile, "End worker reached.\n"); execute_active=FALSE; release_ref(inputlist[0]); //interp_stop(); return 0; } #ifdef NINTENDO_DS const char keyLetters[15] = "ABESRLUD><XYMC"; #define MAX_KEY_BITS 14 #endif int vis_getinput(datum ** inputlist, queue_entry * worker_entry) { #ifdef NINTENDO_DS int held,i,pos; char tempstring[14]; scanKeys(); held = keysHeld(); if(held) { pos = 0; for(i = 0; i < MAX_KEY_BITS; ++i) if(held & (1 << i)) tempstring[pos++] = keyLetters[i]; inputlist[0] = new_datum(BUILTIN_TYPE_STRING, 1, pos+1, worker_entry->instance->def->program); memcpy(inputlist[0]->c.generic.data, tempstring, pos); ((char *)inputlist[0]->c.generic.data)[pos]='\0'; return 0; } else { requeue(worker_entry->worker_num, worker_entry->instance); return 1; } #else #ifdef CONSOLE gets(text_buf); text_buf_size = strlen(text_buf); //Nasty hack for testing until I get around to supporting command line args propery //text_buf_size = strlen(global_argv[1]); #else while(text_buf_size <= 0) { Sleep(30); //TODO: replace with I/O queue mechanism } #endif // VIS_EnterCriticalSection(text_buf_lock); DEBUGPRINTF("Allocating %d bytes\n", text_buf_size+1); inputlist[0] = new_datum(BUILTIN_TYPE_STRING, 1, text_buf_size+1, worker_entry->instance->def->program); DEBUGPUTS("Allocated datum.\n"); memcpy(inputlist[0]->c.generic.data, text_buf, text_buf_size); DEBUGPUTS("Copied string.\n"); ((char *)inputlist[0]->c.generic.data)[text_buf_size]='\0'; DEBUGPRINTF("Input is %s\n", inputlist[0]->c.generic.data); text_buf_size = 0; // VIS_LeaveCriticalSection(text_buf_lock); return 0; #endif } int vis_if(datum ** inputlist, queue_entry * worker_entry) { if(!(inputlist[0]->c.integers.num_a)) { inputlist[1] = inputlist[0]; inputlist[0] = NULL; } else inputlist[1] = NULL; return 0; } int vis_build(datum ** inputlist, queue_entry * worker_entry) { int i,j; company * companylist = worker_entry->instance->def->program->companylist; int num_companies = worker_entry->instance->def->program->num_companies; DEBUGPRINTF("Looking for company named %s\n", inputlist[0]->c.generic.data); for(i = 0; i < num_companies; ++i) { DEBUGPRINTF("Checking company %d:%s\n", i, companylist[i].name); if(!strcmp(inputlist[0]->c.generic.data, companylist[i].name)) break; } release_ref(inputlist[0]); if(i < num_companies && companylist[i].build_size > 0) { DEBUGPRINTF("Building company with size %d\n", companylist[i].build_size); inputlist[0] = new_datum(i, 1, companylist[i].build_size, worker_entry->instance->def->program); for(j = 0; j < companylist[i].build_size; ++j) ((char*)(inputlist[0]->c.generic.data))[j] = 0; } else { DEBUGPUTS("Could not find company\n"); inputlist[0] = NULL; } return 0; } int vis_wait_forever(datum ** inputlist, queue_entry * worker_entry) { return 1; } int init_global_store(datum ** inputlist, queue_entry * worker_entry) { datum * params[3]; global_store * store; datum * store_dat = new_datum(BUILTIN_TYPE_GLOBAL_STORE, 1, sizeof(global_store), worker_entry->instance->def->program); store = store_dat->c.generic.data; store->name = add_ref(inputlist[0]); store->data = create_dict(worker_entry->instance->def->program); VIS_EnterCriticalSection(global_store_lock); params[0] = global_store_dict; params[1] = inputlist[0]; params[2] = store_dat; vis_dict_set(params, NULL); global_store_dict = params[0]; DEBUGPUTS("Global store init complete\n"); VIS_LeaveCriticalSection(global_store_lock); DEBUGPUTS("Released global_store_lock\n"); inputlist[0] = NULL; return 0; } int vis_type_of(datum ** inputlist, queue_entry * worker_entry) { datum * output = make_string(inputlist[0]->company->name, -1, worker_entry->instance->def->program); release_ref(inputlist[0]); inputlist[0] = output; return 0; } int vis_random(datum ** inputlist, queue_entry * worker_entry) { inputlist[0] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); VIS_EnterCriticalSection(randlock); inputlist[0]->c.integers.num_a = genrand_int32(); VIS_LeaveCriticalSection(randlock); return 0; }