bool_t diff_reg(mem_t oldr, mem_t newr, FILE *outfile) { word_t pos; int len = oldr->len; bool_t diff = FALSE; if (newr->len < len) len = newr->len; //write back if(oldr->ca) oldr->ca->clear(TRUE); if(newr->ca) newr->ca->clear(TRUE); for (pos = 0; (!diff || outfile) && pos < len; pos += 4) { word_t ov = 0; word_t nv = 0; oldr->getWord(pos, &ov); newr->getWord(pos, &nv); if (nv != ov) { diff = TRUE; if (outfile) fprintf(outfile, "%s:\t0x%.8x\t0x%.8x\n", reg_table[pos/4].name, ov, nv); } } return diff; }
bool_t diff_mem(mem_t oldm, mem_t newm, FILE *outfile) { word_t pos; int len = oldm->len; bool_t diff = FALSE; if (newm->len < len) len = newm->len; // write back if(oldm->ca) oldm->ca->clear(TRUE); if(newm->ca) newm->ca->clear(TRUE); //remove bus /* if(oldm->bus) oldm->bus->remove(oldm); if(newm->bus) newm->bus->remove(newm); */ for (pos = 0; (!diff || outfile) && pos+4 <= len; pos += 4) { word_t ov = 0; word_t nv = 0; oldm->getWord(pos, &ov); newm->getWord(pos, &nv); if (nv != ov) { diff = TRUE; if (outfile) fprintf(outfile, "0x%.4x:\t0x%.8x\t0x%.8x\n", pos, ov, nv); } } //return *oldm->m != *newm->m; return diff; }
void pinnedFree(T *ptr) { mem_iter iter = pinned_maps.find((void *)ptr); if (iter != pinned_maps.end()) { iter->second.is_free = true; pinned_used_bytes -= iter->second.bytes; } else { pinnedFreeWrapper(ptr); // Free it because we are not sure what the size is } }
virtual void solve(int nt) final { // multiple calls to sovlve() are meant to advance the solution by nt nt += timestep; // being generous about out-of-loop barriers if (timestep == 0) { mem->barrier(); #if !defined(NDEBUG) hook_ante_loop_called = false; #endif hook_ante_loop(nt); mem->barrier(); } // moved here so that if an exception is thrown from hook_ante_loop these do not cause complaints #if !defined(NDEBUG) hook_ante_step_called = false; hook_post_step_called = false; #endif while (timestep < nt) { // progress-bar info through thread name (check top -H) monitor(float(timestep) / nt); // TODO: does this value make sanse with repeated advence() calls? // might be used to implement multi-threaded signal handling mem->barrier(); if (mem->panic) break; // proper solver stuff hook_ante_step(); for (int e = 0; e < n_eqns; ++e) scale(e, ct_params_t::hint_scale(e)); for (int e = 0; e < n_eqns; ++e) xchng(e); for (int e = 0; e < n_eqns; ++e) { advop(e); if (e != n_eqns - 1) mem->barrier(); } for (int e = 0; e < n_eqns; ++e) cycle(e); // note: cycle assumes ascending loop index for (int e = 0; e < n_eqns; ++e) scale(e, -ct_params_t::hint_scale(e)); timestep++; hook_post_step(); } mem->barrier(); // note: hook_post_loop was removed as conficling with multiple-advance()-call logic }
void pinnedGarbageCollect() { for(mem_iter iter = pinned_maps.begin(); iter != pinned_maps.end(); ++iter) { if ((iter->second).is_free) { pinnedFreeWrapper(iter->first); } } mem_iter memory_curr = pinned_maps.begin(); mem_iter memory_end = pinned_maps.end(); while(memory_curr != memory_end) { if (memory_curr->second.is_free) { pinned_maps.erase(memory_curr++); } else { ++memory_curr; } } }
T* pinnedAlloc(const size_t &elements) { managerInit(); T* ptr = NULL; // Allocate the higher megabyte. Overhead of creating pinned memory is // more so we want more resuable memory. size_t alloc_bytes = divup(sizeof(T) * elements, 1048576) * 1048576; if (elements > 0) { // FIXME: Add better checks for garbage collection // Perhaps look at total memory available as a metric if (pinned_maps.size() >= MAX_BUFFERS || pinned_used_bytes >= MAX_BYTES) { pinnedGarbageCollect(); } for(mem_iter iter = pinned_maps.begin(); iter != pinned_maps.end(); ++iter) { mem_info info = iter->second; if (info.is_free && info.bytes == alloc_bytes) { iter->second.is_free = false; pinned_used_bytes += alloc_bytes; return (T *)iter->first; } } // Perform garbage collection if memory can not be allocated if (cudaMallocHost((void **)&ptr, alloc_bytes) != cudaSuccess) { pinnedGarbageCollect(); CUDA_CHECK(cudaMallocHost((void **)(&ptr), alloc_bytes)); } mem_info info = {false, false, alloc_bytes}; pinned_maps[ptr] = info; pinned_used_bytes += alloc_bytes; } return (T*)ptr; }
/* CACHE */ CacheRec::CacheRec(mem_t target, int b, int s, int E, int t): cb(b),cB(1<<b),cs(s),cS(1<<s),cE(E),ct(t),nlines(E<<s){ len = target->getLen(); tm = target; contents = new byte_t[nlines<<b]; valid = new bool_t[nlines]; dirty = new bool_t[nlines]; tags = new byte_t[nlines]; clear(); #ifdef CHECK_CACHE checker = copy_mem(target); #else checker = NULL; #endif }
virtual void cycle(int e) final { n[e] = (n[e] + 1) % n_tlev - n_tlev; // -n_tlev so that n+1 does not give out of bounds if (e == n_eqns - 1) mem->cycle(rank); }
bool exec( int instruction ) { // printf( "EXEC: %d\n", instruction ); switch( instruction ) { // moo case 0: { if( prog_pos == program.begin() ) quit( true ); prog_pos--; // skip previous command. int level = 1; while( level > 0 ) { if( prog_pos == program.begin() ) break; prog_pos--; if( (*prog_pos) == 0 ) level++; else if( (*prog_pos) == 7 ) // look for MOO level--; } if( level != 0 ) quit(true); return exec( *prog_pos ); } // mOo case 1: if( mem_poses[stomach] == memory[stomach].begin() ) quit( true ); else mem_poses[stomach]--; break; // moO case 2: mem_poses[stomach]++; if( mem_poses[stomach] == memory[stomach].end() ) { memory[stomach].push_back(0); mem_poses[stomach] = memory[stomach].end(); mem_poses[stomach]--; } break; // mOO case 3: if( (*mem_poses[stomach]) == 3 ) quit( false ); return exec(*mem_poses[stomach]); // Moo case 4: if( (*mem_poses[stomach]) != 0 ) printf( "%c", *mem_poses[stomach] ); else { (*mem_poses[stomach]) = getchar(); while( getchar() != '\n' ); } break; // MOo case 5: (*mem_poses[stomach])--; break; // MoO case 6: (*mem_poses[stomach])++; break; // MOO case 7: if( (*mem_poses[stomach]) == 0 ) { int level = 1; int prev = 0; prog_pos++; // have to skip past next command when looking for next moo. if( prog_pos == program.end() ) break; while( level > 0 ) { prev = *prog_pos; prog_pos++; if( prog_pos == program.end() ) break; if( (*prog_pos) == 7 ) level++; else if( (*prog_pos) == 0 ) // look for moo command. { level--; if( prev == 7 ) level--; } } if( level != 0 ) quit( true ); } break; // OOO case 8: (*mem_poses[stomach]) = 0; break; // MMM case 9: if( has_register_val ) (*mem_poses[stomach]) = register_val; else register_val = (*mem_poses[stomach]); has_register_val = !has_register_val; break; // OOM case 10: printf( "%d\n", *mem_poses[stomach] ); break; // oom case 11: { char buf[100]; unsigned int c = 0; while( c < sizeof(buf)-1 ) { buf[c] = getchar(); c++; buf[c] = 0; if( buf[c-1] == '\n' ) break; } // swallow, just in case. if( c == sizeof(buf) ) while( getchar() != '\n' ); (*mem_poses[stomach]) = atoi( buf ); break; } // MMm case 12: { stomach--; if(stomach < 0) stomach += num_stomachs; break; } // MmM case 13: { stomach++; if(stomach >= num_stomachs) stomach -= num_stomachs; break; } // Oom case 14: { for( int i=0; i<num_stomachs; ++i ) { if( mem_poses[i] == memory[i].begin() ) quit( true ); else mem_poses[i]--; } break; } // oOm case 15: { for( int i=0; i<num_stomachs; ++i ) { mem_poses[i]++; if( mem_poses[i] == memory[i].end() ) { memory[i].push_back(0); mem_poses[i] = memory[i].end(); mem_poses[i]--; } } break; } // OoM case 16: { for( int i=0; i<num_stomachs; ++i ) { (*mem_poses[i])--; } break; } // oOM case 17: { for( int i=0; i<num_stomachs; ++i) { (*mem_poses[i])++; } break; } // ooo case 18: { for( int i=0; i<num_stomachs; ++i) { (*mem_poses[i]) = 0; } break; } // mmm case 19: { if( has_register_val ) { int weight = 0; for( int i=0; i<num_stomachs; ++i) { if( *mem_poses[i] > 0 ) weight += *mem_poses[i]; } if( weight == 0 ) { for( int i=0; i<num_stomachs; ++i ) { *mem_poses[i] = register_val; } } else { int div = register_val / weight; int mod = register_val - div * weight; for( int i=0; i<num_stomachs; ++i ) { if( *mem_poses[i] > 0 ) *mem_poses[i] = *mem_poses[i] * div; else if( *mem_poses[i] < 0 ) *mem_poses[i] = mod * -*mem_poses[i]; else *mem_poses[i] = 0; } } } else { int sum = 0; for( int i=0; i<num_stomachs; ++i) { sum += *mem_poses[i]; } register_val = sum; } has_register_val = !has_register_val; break; } // bad stuff default: quit( false ); }; prog_pos++; return true; }
int main( int argc, char** argv ) { if( argc < 2 ) { printf( "Usage: %s program.cow\n\n", argv[0] ); exit( 1 ); } FILE* f = fopen( argv[1], "rb" ); if( f == NULL ) { printf( "Cannot open source file [%s].\n", argv[1] ); exit( 1 ); } char buf[3]; memset( buf, 0, 3 ); //int pos = 0; // tola: unused? while( !feof(f) ) { int found = 0; buf[2] = fgetc( f ); if(( found = !strncmp( "moo", buf, 3 ) )) program.push_back( 0 ); else if(( found = !strncmp( "mOo", buf, 3 ) )) program.push_back( 1 ); else if(( found = !strncmp( "moO", buf, 3 ) )) program.push_back( 2 ); else if(( found = !strncmp( "mOO", buf, 3 ) )) program.push_back( 3 ); else if(( found = !strncmp( "Moo", buf, 3 ) )) program.push_back( 4 ); else if(( found = !strncmp( "MOo", buf, 3 ) )) program.push_back( 5 ); else if(( found = !strncmp( "MoO", buf, 3 ) )) program.push_back( 6 ); else if(( found = !strncmp( "MOO", buf, 3 ) )) program.push_back( 7 ); else if(( found = !strncmp( "OOO", buf, 3 ) )) program.push_back( 8 ); else if(( found = !strncmp( "MMM", buf, 3 ) )) program.push_back( 9 ); else if(( found = !strncmp( "OOM", buf, 3 ) )) program.push_back( 10 ); else if(( found = !strncmp( "oom", buf, 3 ) )) program.push_back( 11 ); // from here down, distributed digestion specific calls else if(( found = !strncmp( "MMm", buf, 3 ) )) program.push_back( 12 ); else if(( found = !strncmp( "MmM", buf, 3 ) )) program.push_back( 13 ); else if(( found = !strncmp( "Oom", buf, 3 ) )) program.push_back( 14 ); else if(( found = !strncmp( "oOm", buf, 3 ) )) program.push_back( 15 ); else if(( found = !strncmp( "OoM", buf, 3 ) )) program.push_back( 16 ); else if(( found = !strncmp( "oOM", buf, 3 ) )) program.push_back( 17 ); else if(( found = !strncmp( "ooo", buf, 3 ) )) program.push_back( 18 ); else if(( found = !strncmp( "mmm", buf, 3 ) )) program.push_back( 19 ); if( found ) { memset( buf, 0, 3 ); } else { buf[0] = buf[1]; buf[1] = buf[2]; buf[2] = 0; } } fclose( f ); printf( "Welcome to COW!\n\nExecuting [%s]...\n\n", argv[1] ); // init main memory. for(int i=0; i<num_stomachs; ++i) { memory[i].push_back(0); mem_poses[i] = memory[i].begin(); } stomach = 0; prog_pos = program.begin(); while( prog_pos != program.end() ) if( !exec( *prog_pos ) ) break; quit( false ); return 0; }
bool compile( int instruction, bool advance ) { switch( instruction ) { // moo case 0: { int level = 1; int num = MOOcount + 1; mem_t::iterator t = prog_pos; t--; // skip past previous command when searching for MOO. if( t != program.begin() ) { if((*t) == 7 ) num--; while( level > 0 ) { if( t == program.begin() ) break; t--; if( (*t) == 0 ) level++; else if( (*t) == 7 ) // look for MOO { level--; num--; } } } if( level != 0 && advance ) quit(); else if( level != 0 ) { fprintf( output, "rterr();" ); break; } moocount++; fprintf( output, "goto M%d;", num ); fprintf( output, "m%d:", moocount ); PRETTY( "moo" ); } break; // mOo case 1: fprintf( output, "if(p==m.begin()){rterr();}else{p--;}" ); PRETTY( "mOo" ); break; // moO case 2: fprintf( output, "p++; if(p==m.end()){m.push_back(0);p=m.end();p--;}" ); PRETTY( "moO" ); break; // mOO case 3: // I think it should be possible to build a switch statement here and then // use the compile function itself to fill in the possibilities. // printf( "NOT IMPLEMENTED: mOO\n\n" ); // quit(); fprintf( output, "switch(*p){" ); fprintf( output, "case 0:{" ); compile( 0, false ); fprintf( output, "}break;" ); fprintf( output, "case 1:{" ); compile( 1, false ); fprintf( output, "}break;" ); fprintf( output, "case 2:{" ); compile( 2, false ); fprintf( output, "}break;" ); fprintf( output, "case 4:{" ); compile( 4, false ); fprintf( output, "}break;" ); fprintf( output, "case 5:{" ); compile( 5, false ); fprintf( output, "}break;" ); fprintf( output, "case 6:{" ); compile( 6, false ); fprintf( output, "}break;" ); fprintf( output, "case 7:{" ); compile( 7, false ); fprintf( output, "}break;" ); fprintf( output, "case 8:{" ); compile( 8, false ); fprintf( output, "}break;" ); fprintf( output, "case 9:{" ); compile( 9, false ); fprintf( output, "}break;" ); fprintf( output, "case 10:{" ); compile( 10, false ); fprintf( output, "}break;" ); fprintf( output, "case 11:{" ); compile( 11, false ); fprintf( output, "}break;" ); fprintf( output, "default:{goto x;}};" ); PRETTY( "mOO" ); break; // Moo case 4: fprintf( output, "if((*p)!=0){putchar(*p);}else{(*p)=getchar();while(getchar()!='\\n');}" ); PRETTY( "Moo" ); break; // MOo case 5: fprintf( output, "(*p)--;" ); PRETTY( "MOo" ); break; // MoO case 6: fprintf( output, "(*p)++;" ); PRETTY( "MoO" ); break; // MOO case 7: { int level = 1; int num = moocount; int prev = 0; mem_t::iterator t = prog_pos; t++; // have to skip past next command when looking for next moo. if( t != program.end() ) { if( (*t) == 0 ) num++; while( level > 0 ) { prev = *t; t++; if( t == program.end() ) break; if( (*t) == 7 ) // look for MOO command. level++; else if( (*t) == 0 ) // look for moo command. { if( prev == 7 ) level--; level--; num++; } if( level == 0 ) break; } } if( advance && level != 0 ) quit(); else if( level != 0 ) { fprintf( output, "rterr();" ); break; } MOOcount++; fprintf( output, "M%d:", MOOcount ); fprintf( output, "if(!(*p))goto m%d;", num ); PRETTY( "MOO" ); } break; // OOO case 8: fprintf( output, "(*p)=0;" ); PRETTY( "OOO" ); break; // MMM case 9: fprintf( output, "if(h){(*p)=r;}else{r=(*p);}h=!h;" ); PRETTY( "MMM" ); break; // OOM case 10: fprintf( output, "printf(\"%%d\\n\",*p);" ); PRETTY( "OOM" ); break; // oom case 11: fprintf( output, "char b[100];int c=0;" ); fprintf( output, "while(c<sizeof(b)-1){b[c]=getchar();c++;b[c]=0;if(b[c-1]=='\\n')break;}" ); fprintf( output, "if(c==sizeof(b))while(getchar()!='\\n');(*p)=atoi(b);" ); PRETTY( "oom" ); break; // bad stuff default: return false; }; if( advance ) prog_pos++; return true; }
int main( int argc, char** argv ) { if( argc < 2 ) { printf( "Usage: %s program.cow\n\n", argv[0] ); exit( 1 ); } FILE* f = fopen( argv[1], "rb" ); if( f == NULL ) { printf( "Cannot open source file [%s].\n", argv[1] ); exit( 1 ); } char buf[3]; memset( buf, 0, 3 ); int pos = 0; while( !feof(f) ) { int found = 0; buf[2] = fgetc( f ); if( found = !strncmp( "moo", buf, 3 ) ) program.push_back( 0 ); else if( found = !strncmp( "mOo", buf, 3 ) ) program.push_back( 1 ); else if( found = !strncmp( "moO", buf, 3 ) ) program.push_back( 2 ); else if( found = !strncmp( "mOO", buf, 3 ) ) program.push_back( 3 ); else if( found = !strncmp( "Moo", buf, 3 ) ) program.push_back( 4 ); else if( found = !strncmp( "MOo", buf, 3 ) ) program.push_back( 5 ); else if( found = !strncmp( "MoO", buf, 3 ) ) program.push_back( 6 ); else if( found = !strncmp( "MOO", buf, 3 ) ) program.push_back( 7 ); else if( found = !strncmp( "OOO", buf, 3 ) ) program.push_back( 8 ); else if( found = !strncmp( "MMM", buf, 3 ) ) program.push_back( 9 ); else if( found = !strncmp( "OOM", buf, 3 ) ) program.push_back( 10 ); else if( found = !strncmp( "oom", buf, 3 ) ) program.push_back( 11 ); if( found ) { memset( buf, 0, 3 ); } else { buf[0] = buf[1]; buf[1] = buf[2]; buf[2] = 0; } } fclose( f ); printf( "Compiling [%s]...\n", argv[1] ); // init main memory. /* memory.push_back( 0 ); mem_pos = memory.begin(); */ output = fopen( "cow.out.cpp", "wb" ); fprintf( output, "#include <stdio.h>\n" ); fprintf( output, "#include <vector>\n" ); fprintf( output, "typedef std::vector<int> t_;t_ m;t_::iterator p;\n" ); fprintf( output, "bool h;int r;\n" ); fprintf( output, "void rterr(){puts(\"Runtime error.\\n\");}\n" ); fprintf( output, "int main(int a,char** v){\n" ); fprintf( output, "m.push_back(0);p=m.begin();h=false;\n" ); prog_pos = program.begin(); while( prog_pos != program.end() ) if( !compile( *prog_pos, true ) ) { printf( "ERROR!\n" ); break; } fprintf( output, "x:return(0);}\n" ); fclose( output ); printf( "C++ source code: cow.out.cpp\n" ); #ifdef COMPILER std::string path( (const char*)COMPILER ); path.append( " " ); path.append( (const char*)NAME_FLAG ); path.append( " " ); path.append( (const char*)OUTPUT_EXEC ); path.append( " " ); path.append( (const char*)FLAGS ); path.append( " " ); path.append( (const char*)OUTPUT_CPP ); if( system( path.c_str() ) ) printf( "\n\nCould not compile. Possible causes: C++ compiler is not installed, not in path, or not named '%s' or there is a bug in this compiler.\n\n", COMPILER ); else printf( "Executable created: cow.out\n" ); #endif return 0; }
bool op_ring::execute() { if( pos != 0 ) switch( pos ) { // One case 2: value=1; break; // Zero case 3: value=0; break; // Load case 4: value=*mem_pos; break; // Store case 5: *mem_pos = value; break; // DAdd case 7: { int t = mem_pos - memory.begin(); t += value; if( t < 0 ) return false; // out of bounds! if( t < memory.size() ) mem_pos = memory.begin() + t; else { while( memory.size() <= t ) memory.push_back(0); mem_pos = memory.begin() + t; } } break; // Logic case 8: if( *mem_pos != 0 ) value = value && 1; else value = 0; break; // If case 9: if( *mem_pos == 0 ) break; // else fall through! // PAdd case 6: { int t = prog_pos - program.begin(); t += value; if( t < 0 || t >= program.size() ) return false; // out of bounds! prog_pos = program.begin() + t; next_instruction = false; } break; // IntIO case 10: if( value == 0 ) { // read integer char buf[100]; int c = 0; while( c < sizeof(buf)-1 ) { buf[c] = getchar(); c++; buf[c] = 0; if( buf[c-1] == '\n' ) break; } // swallow, just in case. if( c == sizeof(buf) ) while( getchar() != '\n' ); (*mem_pos) = atoi( buf ); } else printf( "%d", *mem_pos ); break; // AscIO case 11: if( value == 0 ) { // read character (*mem_pos) = getchar(); while( getchar() != '\n' ); } else printf( "%c", *mem_pos ); break; // Exit case 1: default: return false; } return true; }
int main( int argc, char** argv ) { if( argc < 2 ) { printf( "Usage: %s program.wrl\n\n", argv[0] ); exit( 1 ); } FILE* f = fopen( argv[1], "rb" ); if( f == NULL ) { printf( "Cannot open source file [%s].\n", argv[1] ); exit( 1 ); } while( !feof(f) ) { char buf = fgetc( f ); if( buf == '1' ) program.push_back( true ); else if( buf == '0' ) program.push_back( false ); } fclose( f ); printf( "Welcome to Whirl!\n\nExecuting [%s]...\n\n", argv[1] ); // init main memory. memory.push_back( 0 ); mem_pos = memory.begin(); prog_pos = program.begin(); bool execute = false; while( prog_pos != program.end() ) { next_instruction = true; if( *prog_pos ) { cur->rotate(); execute = false; } else { cur->switch_dir(); if( execute ) { if( !cur->execute() ) return 0; (cur == &ops)? cur = &math: cur = &ops; execute = false; } else execute = true; } if( next_instruction ) prog_pos++; } printf( "\n" ); return 0; }