void schedule(void) { word_t action; action = (word_t)ksSchedulerAction; //printf("\n=======In schedule======\n"); if (action == (word_t)SchedulerAction_ChooseNewThread) { printf("in action_choosenewthread\n"); if (isRunnable(ksCurThread)) { tcbSchedEnqueue(ksCurThread); } if (CONFIG_NUM_DOMAINS > 1 && ksDomainTime == 0) { printf("will next domain\n"); nextDomain(); } printf("go to choosethread\n"); chooseThread(); ksSchedulerAction = SchedulerAction_ResumeCurrentThread; } else if (action != (word_t)SchedulerAction_ResumeCurrentThread) { if (isRunnable(ksCurThread)) { tcbSchedEnqueue(ksCurThread); } /* SwitchToThread */ switchToThread(ksSchedulerAction); ksSchedulerAction = SchedulerAction_ResumeCurrentThread; } }
///////////////////////////////////////////////////////// // gem_cacheMess // ///////////////////////////////////////////////////////// void GemBase :: gem_startstopMess(int state) { // for now, this is important, as it is the only way to call the stopRendering #if 1 if (state && !gem_amRendering) { m_enabled = isRunnable(); if(m_enabled) { startRendering(); m_state=RENDERING; } } else if (!state && gem_amRendering) { if(m_enabled) { stopRendering(); m_state=ENABLED; } } gem_amRendering=(state!=0); // continue sending out the cache message t_atom ap[1]; SETFLOAT(ap, state); outlet_anything(this->m_out1, gensym("gem_state"), 1, ap); #else post("gem_startstopMess(%d) called...please report this to the upstream developers", state); #endif }
///////////////////////////////////////////////////////// // renderMess // ///////////////////////////////////////////////////////// void GemBase :: gem_renderMess(GemCache* cache, GemState*state) { m_cache=cache; if(m_cache && m_cache->m_magic!=GEMCACHE_MAGIC) { m_cache=NULL; } if(INIT==m_state) { if(isRunnable()) { m_state=ENABLED; } else { m_state=DISABLED; } } if(MODIFIED==m_state) { stopRendering(); m_state=ENABLED; } if(ENABLED==m_state) { startRendering(); m_state=RENDERING; } if(RENDERING==m_state) { gem_amRendering=true; if(state) { render(state); } continueRender(state); if(state) { postrender(state); } } m_modified=false; }
void chooseThread(void) { word_t prio; word_t dom; tcb_t *thread; if (CONFIG_NUM_DOMAINS > 1) { dom = ksCurDomain; } else { dom = 0; } if (likely(ksReadyQueuesL1Bitmap[dom])) { word_t l1index = (wordBits - 1) - clzl(ksReadyQueuesL1Bitmap[dom]); word_t l2index = (wordBits - 1) - clzl(ksReadyQueuesL2Bitmap[dom][l1index]); prio = l1index_to_prio(l1index) | l2index; thread = ksReadyQueues[ready_queues_index(dom, prio)].head; assert(thread); assert(isRunnable(thread)); switchToThread(thread); } else { switchToIdleThread(); } }
void chooseThread(void) { word_t prio; word_t dom; tcb_t *thread; if (CONFIG_NUM_DOMAINS > 1) { dom = ksCurDomain; } else { dom = 0; } //printf("\n====In chooseThread=====\n"); //printf("domain is %d\n", dom); if (likely(ksReadyQueuesL1Bitmap[dom])) { uint32_t l1index = (wordBits - 1) - CLZ(ksReadyQueuesL1Bitmap[dom]); uint32_t l2index = (wordBits - 1) - CLZ(ksReadyQueuesL2Bitmap[dom][l1index]); prio = l1index_to_prio(l1index) | l2index; thread = ksReadyQueues[ready_queues_index(dom, prio)].head; assert(thread); assert(isRunnable(thread)); //printf("will call switchToThread(%p)\n", thread); //printf("its prio is %d\n", thread->tcbPriority); switchToThread(thread); return; } //printf(" IDLE THREAD\n"); switchToIdleThread(); }
void scheduleTCB(tcb_t *tptr) { if (tptr == ksCurThread && ksSchedulerAction == SchedulerAction_ResumeCurrentThread && !isRunnable(tptr)) { rescheduleRequired(); } }
void setPolicy(tcb_t *tptr, policy_t policy) { tcbSchedDequeue(tptr); tptr->tcbPolicy = policy; if (isRunnable(tptr)) { tcbSchedEnqueue(tptr); } if (tptr == ksCurThread) { rescheduleRequired(); } }
void setDomain(tcb_t *tptr, dom_t dom) { tcbSchedDequeue(tptr); tptr->tcbDomain = dom; if (isRunnable(tptr)) { tcbSchedEnqueue(tptr); } if (tptr == ksCurThread) { rescheduleRequired(); } }
void setPriority(tcb_t *tptr, prio_t prio) { tcbSchedDequeue(tptr); tptr->tcbPriority = prio; if (isRunnable(tptr)) { tcbSchedEnqueue(tptr); } if (tptr == ksCurThread) { rescheduleRequired(); } }
void glsl_vertex :: openMess(t_symbol *filename) { if(NULL==filename || NULL==filename->s_name)return; if(&s_==filename)return; if( !GLEW_VERSION_1_1 ) { /* stupid check whether we have a valid context */ post("shader '%s' will be loaded when rendering is turned on (openGL context needed)", filename->s_name); m_shaderFilename=filename; return; } if(!isRunnable()) { return; } // Clean up any open files closeMess(); std::string fn = findFile(filename->s_name); const char*buf=fn.c_str(); FILE *file = fopen(buf,"rb"); if(file) { fseek(file,0,SEEK_END); long size = ftell(file); if(size<0){fclose(file);error("error reading filesize");return;} m_shaderString = new char[size + 1]; memset(m_shaderString,0,size + 1); fseek(file,0,SEEK_SET); size_t count=fread(m_shaderString,1,size,file); int err=ferror(file); fclose(file); if(err){error("error %d reading file (%d<%d)", err, count, size); return;} } else { error("could not find shader-file: '%s'", buf); return; /* // assuming that the "filename" is actually a shader-program per se m_shaderString = new char[strlen(buf) + 1]; strcpy(m_shaderString,buf); */ } m_size=strlen(m_shaderString); if(GLEW_VERSION_2_0) openMessGL2(); else if (GLEW_ARB_vertex_shader) openMessARB(); logpost(NULL, 5, "Loaded file: %s", buf); m_shaderFilename=NULL; }
bool C64::loadRom(const char *filename) { bool result = false; suspend(); bool wasRunnable = isRunnable(); if (C64Memory::isBasicRom(filename)) { result = mem->loadBasicRom(filename); if (result) putMessage(MSG_ROM_LOADED, BASIC_ROM); } if (C64Memory::isCharRom(filename)) { result = mem->loadCharRom(filename); if (result) putMessage(MSG_ROM_LOADED, CHAR_ROM); } if (C64Memory::isKernelRom(filename)) { result = mem->loadKernelRom(filename); if (result) putMessage(MSG_ROM_LOADED, KERNEL_ROM); } if (VC1541Memory::is1541Rom(filename)) { result = floppy->mem->loadRom(filename); if (result) putMessage(MSG_ROM_LOADED, VC1541_ROM); } bool isNowRunnable = isRunnable(); if (!wasRunnable && isNowRunnable) { // Last missing ROM was loaded putMessage(MSG_ROM_COMPLETE); } resume(); return result; }
bool C64::loadRom(const char *filename) { bool result = false; debug(1, "Trying to load ROM image %s\n", filename); suspend(); bool wasRunnable = isRunnable(); if (C64Memory::isBasicRom(filename)) { result = mem.loadBasicRom(filename); if (result) putMessage(MSG_ROM_LOADED, BASIC_ROM); } if (C64Memory::isCharRom(filename)) { result = mem.loadCharRom(filename); if (result) putMessage(MSG_ROM_LOADED, CHAR_ROM); } if (C64Memory::isKernelRom(filename)) { result = mem.loadKernelRom(filename); if (result) putMessage(MSG_ROM_LOADED, KERNEL_ROM); } if (VC1541Memory::is1541Rom(filename)) { result = floppy.mem.loadRom(filename); if (result) putMessage(MSG_ROM_LOADED, VC1541_ROM); } bool isNowRunnable = isRunnable(); if (!wasRunnable && isNowRunnable) { // Good news! All ROMs are in place putMessage(MSG_ROM_COMPLETE); } resume(); return result; }
void schedule(void) { word_t action; action = (word_t)ksSchedulerAction; if (action == (word_t)SchedulerAction_ChooseNewThread) { if (isRunnable(ksCurThread)) { tcbSchedEnqueue(ksCurThread); } if (ksDomainTime == 0) { nextDomain(); } chooseThread(); ksSchedulerAction = SchedulerAction_ResumeCurrentThread; } else if (action != (word_t)SchedulerAction_ResumeCurrentThread) { if (isRunnable(ksCurThread)) { tcbSchedEnqueue(ksCurThread); } /* SwitchToThread */ switchToThread(ksSchedulerAction); ksSchedulerAction = SchedulerAction_ResumeCurrentThread; } }
void glsl_vertex :: loadShader() { if(NULL==m_shaderFilename || NULL==m_shaderFilename->s_name)return; if(!isRunnable()) { return; } // Clean up any open files closeMess(); std::string fn = findFile(m_shaderFilename->s_name); const char*buf=fn.c_str(); FILE *file = fopen(buf,"rb"); if(file) { fseek(file,0,SEEK_END); long size = ftell(file); if(size<0){fclose(file);error("error reading filesize");return;} m_shaderString = new char[size + 1]; memset(m_shaderString,0,size + 1); fseek(file,0,SEEK_SET); size_t count=fread(m_shaderString,1,size,file); m_shaderString[size]='\0'; int err=ferror(file); fclose(file); if(err){error("error %d reading file (%d<%d)", err, count, size); return;} } else { error("could not find shader-file: '%s'", buf); return; /* // assuming that the "filename" is actually a shader-program per se m_shaderString = new char[strlen(buf) + 1]; strcpy(m_shaderString,buf); */ } m_size=strlen(m_shaderString); if(GLEW_VERSION_2_0) openMessGL2(); else if (GLEW_ARB_vertex_shader) openMessARB(); verbose(1, "Loaded file: %s", buf); m_shaderFilename=NULL; }
void chooseThread(void) { int p; tcb_t *thread; for (p = seL4_MaxPrio; p != -1; p--) { unsigned int domprio = ksCurDomain * CONFIG_NUM_PRIORITIES + p; thread = ksReadyQueues[domprio].head; if (thread != NULL) { assert(isRunnable(thread)); switchToThread(thread); return; } } switchToIdleThread(); }
void timerTick(void) { if (likely(isRunnable(ksCurThread))) { if (ksCurThread->tcbTimeSlice > 1) { ksCurThread->tcbTimeSlice--; } else { ksCurThread->tcbTimeSlice = CONFIG_TIME_SLICE; tcbSchedAppend(ksCurThread); rescheduleRequired(); } } if (CONFIG_NUM_DOMAINS > 1) { ksDomainTime--; if (ksDomainTime == 0) { rescheduleRequired(); } } }
void timerTick(void) { /* printf("\n========in timertick==========\n"); */ if (likely(isRunnable(ksCurThread))) { if (ksCurThread->tcbTimeSlice > 1) { ksCurThread->tcbTimeSlice--; } else { ksCurThread->tcbTimeSlice = CONFIG_TIME_SLICE; tcbSchedAppend(ksCurThread); rescheduleRequired(); } } if (CONFIG_NUM_DOMAINS > 1) { /* printf("num domain is %d\n", CONFIG_NUM_DOMAINS); */ ksDomainTime--; /* printf("current domain is %d\n", ksCurDomain); printf("domain time is %d\n", ksDomainTime); */ if (ksDomainTime == 0) { /* printf("action is %d\n", ksSchedulerAction); */ rescheduleRequired(); } } }
void glsl_geometry :: openMess(t_symbol *filename) { if(NULL==filename || NULL==filename->s_name)return; if(&s_==filename)return; if( !GLEW_VERSION_1_1 ) { /* stupid check whether we have a valid context */ post("shader '%s' will be loaded when rendering is turned on (openGL context needed)", filename->s_name); m_shaderFilename=filename; return; } if(!isRunnable()) { return; } // Clean up any open files closeMess(); std::string fn = findFile(filename->s_name); const char*buf=fn.c_str(); FILE *file = fopen(buf,"rb"); if(file) { fseek(file,0,SEEK_END); long size = ftell(file); if(size<0){fclose(file);error("error reading filesize");return;} m_shaderString = new char[size + 1]; memset(m_shaderString,0,size + 1); fseek(file,0,SEEK_SET); size_t count=fread(m_shaderString,1,size,file); m_shaderString[size]='\0'; int err=ferror(file); fclose(file); if(err){error("error %d reading file (%d<%d)", err, count, size); return;} } else { error("could not find shader-file: '%s'", buf); return; /* // assuming that the "filename" is actually a shader-program per se m_shaderString = new char[strlen(buf) + 1]; strcpy(m_shaderString,buf); */ } m_size=strlen(m_shaderString); if(GLEW_EXT_geometry_shader4) // GLEW_VERSION_2_1 openMessGL2(); else if (GLEW_ARB_geometry_shader4) openMessARB(); verbose(1, "Loaded file: %s", buf); m_shaderFilename=NULL; if (m_shader || m_shaderARB) { t_atom a; // send shaderID to outlet gem::utils::glsl::atom_setshader(a, m_shader?m_shader:m_shaderARB); outlet_list(m_outShaderID, gensym("list"), 1, &a); } }