void KDBuildJob::KDBuild(int maxleafsize, int extradepth, bool root)
{
kdbuffer_t l_kdb;
kdbuffer_t r_kdb;
int b = 0;
if(BufferEmpty(kdbuffer[b]))
{
for(int i=0; i < njobs; i++)
sem_post(&jobs[i]->sem);
}
// Make nodes
while(! BufferEmpty(kdbuffer[b]) )
{
kdbuffer_t *kdb = (kdbuffer_t*)kdbuffer[b]->buffer;
int size = BufferNumElements(kdbuffer[b]);
int i;
BufferClear(aabb_buffer[1-b]);
BufferClear(kdbuffer[1-b]);
for(i=0; i < size; i++)
{
l_kdb.node = curnode++;
r_kdb.node = curnode++;
nodes[ kdb[i].node ].split = kdb[i].plane;
nodes[ kdb[i].node ].axis = kdb[i].axis;
nodes[ kdb[i].node ].left = l_kdb.node;
nodes[ kdb[i].node ].right = r_kdb.node;
KDBufferAllocate(&l_kdb, kdb[i].left_size, aabb_buffer[1-b]);
if(curjob < njobs)
KDBufferAllocate(&r_kdb, kdb[i].right_size, jobs[curjob]->aabb_buffer[0]);
else
KDBufferAllocate(&r_kdb, kdb[i].right_size, aabb_buffer[1-b]);
KDPartition(&kdb[i], &l_kdb, &r_kdb);
if(l_kdb.depth == maxdepth || l_kdb.size <= maxleafsize)
{
l_kdb.aabb = (aabb_t*)BufferCopyTo(leaf_aabb_buffer, l_kdb.aabb, l_kdb.count);
BufferCopyTo(leafbuffer, &l_kdb, 1);
}
else
BufferCopyTo(kdbuffer[1-b], &l_kdb, 1);
if(r_kdb.depth == maxdepth || r_kdb.size <= maxleafsize)
{
if(curjob < njobs)
{
r_kdb.aabb = (aabb_t*)BufferCopyTo(jobs[curjob]->leaf_aabb_buffer, r_kdb.aabb, r_kdb.count);
BufferCopyTo(jobs[curjob]->leafbuffer, &r_kdb, 1);
}
else
{
r_kdb.aabb = (aabb_t*)BufferCopyTo(leaf_aabb_buffer, r_kdb.aabb, r_kdb.count);
BufferCopyTo(leafbuffer, &r_kdb, 1);
}
}
else
{
if(curjob < njobs)
BufferCopyTo(jobs[curjob]->kdbuffer[0], &r_kdb, 1);
else
BufferCopyTo(kdbuffer[1-b], &r_kdb, 1);
}
}
if(curjob < njobs)
{
// Start other job
sem_post(&jobs[curjob]->sem);
curjob++;
}
b = 1 - b;
}
// Check if still remaining jobs and start them
while(curjob < njobs)
{
// Start other job
sem_post(&jobs[curjob]->sem);
curjob++;
}
// Make leaves
kdbuffer_t *kdb = (kdbuffer_t*)leafbuffer->buffer;
int size = BufferNumElements(leafbuffer);
//cout << "Make leaves " << size << endl;
int i;
for(i=0; i < size; i++)
{
MakeLeaf(&kdb[i]);
}
numleaves = size;
curleaf = size;
}
void main(void) {
UINT8 input_validity;
UINT8 userInput1,userInput2,userInput3;
UINT8 flag1, flag2;
struct Stepper stepper1,stepper2;
// set up serial port communication
InitializeSerialPort();
InitializePWM();
//Intialize timer
InitializeTimer();
// allocate and fill receipe array
InitializeRecipe();
IntializeLED();
set_stepper(&stepper1,PWM_CHANNEL_STEPPER1,STEPPER1_RECIPE);
set_stepper(&stepper2,PWM_CHANNEL_STEPPER2,STEPPER2_RECIPE);
if(1 == POST())
{
printf("POST failed\r\n");
for(;;)
{
}
}
else
{
printf("POST successful\r\n");
(void)printf(">");
for(;;) {
_FEED_COP();
//check serial port for input
if(1 == BufferEmpty())
{
do
{
userInput1 = GetChar();
(void)printf("%c", userInput1);
userInput2 = GetChar();
(void)printf("%c", userInput2);
//get <CR>
userInput3 = GetChar();
if( 'x' == userInput1 || 'X' == userInput1 || 'x' == userInput2 || 'X' == userInput2 )
{
input_validity = INVALID_INPUTS;
}
else
{
input_validity = VALID_INPUTS;
}
}while(INVALID_INPUTS == input_validity);
// print <LF> and then '>'
(void)printf("\r\n>");
//set state of stepper1
update_state(&stepper1,userInput1);
//set state of stepper2
update_state(&stepper2,userInput2);
}
// for stepper 1 take action according to state
flag1 = take_action(&stepper1);
// for stepper 2 take action acording to state
flag2 = take_action(&stepper2);
glow_led(flag1,flag2);
(void)wait_cycle();
}
}
}
void MakeNodes()
{
uint put_tag[2];
put_tag[0] = mfc_tag_reserve();
put_tag[1] = mfc_tag_reserve();
ushort b = 0;
kdbuffer_t l_kdb ALIGNED(16);
kdbuffer_t r_kdb ALIGNED(16);
kdnode_t node ALIGNED(16);
kdbuffer_t kdb ALIGNED(16);
DoubleBufInit(&aabb_db, 0, 0, sizeof(aabb_t), NUM_AABBS, aabbbuffer[0], aabbbuffer[1]);
// printf("Empty? %i\n", BufferEmpty(&arg.kdbuffer[b]));
while(! BufferEmpty(&arg.kdbuffer[b]) )
{
kdbuffer_t *pkdb = (kdbuffer_t*)arg.kdbuffer[b].buffer;
int size = BufferNumElements(&arg.kdbuffer[b]);
int i;
BufferClear(&arg.aabb_buffer[1-b]);
BufferClear(&arg.kdbuffer[1-b]);
// printf("size %i\n", size);
for(i=0; i < size; i++)
{
l_kdb.node = arg.curnode++;
r_kdb.node = arg.curnode++;
memcpy_ls(&kdb, &pkdb[i], sizeof(kdbuffer_t));
node.split = kdb.plane;
node.axis = kdb.axis;
node.left = l_kdb.node;
node.right = r_kdb.node;
memcpy_ea(&arg.nodes[ kdb.node ], &node, sizeof(kdnode_t));
KDBufferAllocate(&l_kdb, kdb.left_size, &arg.aabb_buffer[1-b]);
if(curjob < arg.njobs)
KDBufferAllocate(&r_kdb, kdb.right_size, &arg.job_aabb_buffer[curjob]);
else
KDBufferAllocate(&r_kdb, kdb.right_size, &arg.aabb_buffer[1-b]);
KDPartitionAll(&kdb, &l_kdb, &r_kdb);
if(l_kdb.depth == arg.maxdepth || l_kdb.size <= arg.maxleafsize)
{
total_leaf_size += l_kdb.count;
l_kdb.aabb = (aabb_t*)BufferCopyTo(&arg.leaf_aabb_buffer, l_kdb.aabb, l_kdb.count);
BufferCopyToLS(&arg.leafbuffer, &l_kdb, 1);
}
else
{
BufferCopyToLS(&arg.kdbuffer[1-b], &l_kdb, 1);
}
if(r_kdb.depth == arg.maxdepth || r_kdb.size <= arg.maxleafsize)
{
total_leaf_size += r_kdb.count;
if(curjob < arg.njobs)
{
r_kdb.aabb = (aabb_t*)BufferCopyTo(&arg.job_leaf_aabb_buffer[curjob], r_kdb.aabb, r_kdb.count);
BufferCopyToLS(&arg.job_leafbuffer[curjob], &r_kdb, 1);
spu_mfcdma32(&arg.job_leafbuffer[curjob], (uint)arg.pjob_leafbuffer[curjob], sizeof(buffer_t), jobtag, MFC_PUT_CMD);
DmaWait(jobtag);
}
else
{
r_kdb.aabb = (aabb_t*)BufferCopyTo(&arg.leaf_aabb_buffer, r_kdb.aabb, r_kdb.count);
BufferCopyToLS(&arg.leafbuffer, &r_kdb, 1);
}
}
else
{
if(curjob < arg.njobs)
{
BufferCopyToLS(&arg.job_kdbuffer[curjob], &r_kdb, 1);
spu_mfcdma32(&arg.job_kdbuffer[curjob], (uint)arg.pjob_kdbuffer[curjob], sizeof(buffer_t), jobtag, MFC_PUT_CMD);
DmaWait(jobtag);
}
else
BufferCopyToLS(&arg.kdbuffer[1-b], &r_kdb, 1);
}
/*
if(curjob < njobs)
KDBufferAllocate(&r_kdb, kdb[i].right_size, &jobs[curjob]->aabb_buffer[0]);
else
KDBufferAllocate(&r_kdb, kdb[i].right_size, &aabb_buffer[1-b]);
KDPartition(&kdb[i], &l_kdb, &r_kdb);
if(l_kdb.depth == maxdepth || l_kdb.size <= maxleafsize)
{
l_kdb.aabb = (aabb_t*)BufferCopyTo(&leaf_aabb_buffer, l_kdb.aabb, l_kdb.count);
BufferCopyTo(&leafbuffer, &l_kdb, 1);
}
else
BufferCopyTo(&kdbuffer[1-b], &l_kdb, 1);
if(r_kdb.depth == maxdepth || r_kdb.size <= maxleafsize)
{
if(curjob < njobs)
{
r_kdb.aabb = (aabb_t*)BufferCopyTo(&jobs[curjob]->leaf_aabb_buffer, r_kdb.aabb, r_kdb.count);
BufferCopyTo(&jobs[curjob]->leafbuffer, &r_kdb, 1);
}
else
{
r_kdb.aabb = (aabb_t*)BufferCopyTo(&leaf_aabb_buffer, r_kdb.aabb, r_kdb.count);
BufferCopyTo(&leafbuffer, &r_kdb, 1);
}
}
else
{
if(curjob < njobs)
BufferCopyTo(&jobs[curjob]->kdbuffer[0], &r_kdb, 1);
else
BufferCopyTo(&kdbuffer[1-b], &r_kdb, 1);
}
*/
if(curjob < arg.njobs)
{
// Start other job
ppe_post_sema(arg.sema[curjob]);
curjob++;
}
}
b = 1 - b;
}
while( curjob < arg.njobs)
{
ppe_post_sema(arg.sema[curjob]);
curjob++;
}
// Transfer back
spu_mfcdma32(&arg.curnode, (unsigned int)arg.pcurnode, (unsigned int)sizeof(int), put_tag[0], MFC_PUT_CMD);
spu_mfcdma32(&total_leaf_size, (unsigned int)arg.ptotal_leaf_size, (unsigned int)sizeof(int), put_tag[1], MFC_PUT_CMD);
DmaWait(put_tag[0]);
DmaWait(put_tag[1]);
spu_mfcdma32(&arg.leafbuffer, (unsigned int)arg.pleafbuffer, (unsigned int)sizeof(buffer_t), put_tag[0], MFC_PUT_CMD);
spu_mfcdma32(&arg.leaf_aabb_buffer, (unsigned int)arg.pleaf_aabb_buffer, (unsigned int)sizeof(buffer_t), put_tag[1], MFC_PUT_CMD);
DmaWaitAll();
mfc_tag_release(put_tag[0]);
mfc_tag_release(put_tag[1]);
}
