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);
}
}
