static void processEvents(LLDBPlugin* plugin, PDReader* reader, PDWriter* writer)
{
uint32_t event;
while ((event = PDRead_get_event(reader)))
{
//printf("LLDBPlugin: %d Got event %s\n", event, eventTypes[event]);
switch (event)
{
case PDEventType_GetExceptionLocation : setExceptionLocation(plugin, writer); break;
case PDEventType_GetCallstack : setCallstack(plugin, writer); break;
case PDEventType_SetExecutable : setExecutable(plugin, reader); break;
case PDEventType_SelectThread : selectThread(plugin, reader, writer); break;
case PDEventType_SelectFrame : selectFrame(plugin, reader, writer); break;
case PDEventType_GetLocals : setLocals(plugin, writer); break;
case PDEventType_GetThreads : setThreads(plugin, writer); break;
case PDEventType_GetSourceFiles : setSourceFiles(plugin, writer); break;
case PDEventType_SetBreakpoint : setBreakpoint(plugin, reader, writer); break;
case PDEventType_Action : eventAction(plugin, reader); break;
}
}
setTty(plugin, writer);
}
void SQPSmoother() {
Thread* start = new Thread(*glThreads[planThread]->getThread());
Thread* end = new Thread(*glThreads[endThread]->getThread());
vector<Thread*> traj;
vector<vector<VectorXd> > mot;
DimensionReductionBestPath(start, end, 0, traj, mot);
initialized = false; // set to false to prevent visualizer from segfault
vector<VectorXd> U;
vector<Thread*> smoothTraj;
vector<Thread*> downSampledTraj;
for (int i = 0; i < traj.size(); i++) {
if ( i % 5 == 0) {
VectorXd ctrl(12);
ctrl.setZero();
U.push_back(ctrl);
smoothTraj.push_back(new Thread(*traj[i]));
downSampledTraj.push_back(new Thread(*traj[i]));
}
}
int numGoalCopies = smoothTraj.size() / 50;
if (numGoalCopies == 0) numGoalCopies = 1;
for (int i = 0; i < numGoalCopies; i++) {
smoothTraj.push_back(new Thread(*end));
VectorXd ctrl(12);
ctrl.setZero();
U.push_back(ctrl);
}
Iterative_Control* ic = new Iterative_Control(smoothTraj.size(), smoothTraj.front()->num_pieces());
int num_iters = 2;
ic->iterative_control_opt(smoothTraj, U, num_iters);
vector<vector<VectorXd> > thread_control_data;
for (int i = 0; i < smoothTraj.size(); i++) {
//vector<Thread*> tmp;
//tmp.push_back(traj[i]);
//thread_visualization_data.push_back(tmp);
vector<VectorXd> motion_wrapper;
motion_wrapper.push_back(U[i]);
thread_control_data.push_back(motion_wrapper);
}
Trajectory_Follower *pathFollower =
new Trajectory_Follower(smoothTraj, thread_control_data, new Thread(*start));
pathFollower->control_to_finish();
vector<Thread*> control_traj;
pathFollower->getReachedStates(control_traj);
vector<vector<Thread*> > thread_visualization_data;
thread_visualization_data.push_back(downSampledTraj);
thread_visualization_data.push_back(smoothTraj);
thread_visualization_data.push_back(control_traj);
setThreads(thread_visualization_data);
}
void interpolateAndFollow() {
Thread* start = new Thread(*glThreads[planThread]->getThread());
Thread* end = new Thread(*glThreads[endThread]->getThread());
numApprox = 100;
vector<Thread*> intp_traj;
intp_traj.resize(numApprox);
intp_traj[0] = new Thread(*start);
intp_traj[intp_traj.size()-1]= new Thread(*end);
vector<VectorXd> controls;
cout << "calling interpolate" << endl;
interpolateThreads(intp_traj, controls);
vector<vector<VectorXd> > intp_controls;
for (int i = 0; i < controls.size(); i++) {
vector<VectorXd> control_wrapper;
control_wrapper.push_back(controls[i]);
intp_controls.push_back(control_wrapper);
}
Trajectory_Follower *pathFollower =
new Trajectory_Follower(intp_traj, intp_controls, start);
pathFollower->control_to_finish();
vector<Thread*> outTraj;
pathFollower->getReachedStates(outTraj);
vector<vector<Thread*> > thread_visualization_data;
thread_visualization_data.push_back(intp_traj);
thread_visualization_data.push_back(outTraj);
setThreads(thread_visualization_data);
}
/**
* Do the same basic thing, but this time compute the primes on the CPU and just
* run a single check to see if it's a divisor, then do an atomic check and set
*/
bool opt_setup()
{
long number = 600851475143L;
int initialVal = 0;
std::vector<int> *primes = prime::EratosthenesPrimesUpTo(sqrt(number));
cl->init("src/problems/P001xP010/P003.cl","optimized");
cl->createWriteOnlyMemory(sizeof(int),&answer_mem);
cl->createReadOnlyMemory(sizeof(long),&number_mem);
cl->createReadOnlyMemory(sizeof(int) * primes->size(),&prime_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->transferCPUObjectToGPU(sizeof(long),&number_mem,&number);
cl->transferCPUObjectToGPU(sizeof(int) * primes->size(),&prime_mem,primes->data());
cl->setupOpenCLKernelArgs(3,
sizeof(cl_mem), &number_mem,
sizeof(cl_mem), &prime_mem,
sizeof(cl_mem), &answer_mem);
cl->waitForQueue(); // sync
setThreads(primes->size()); // check each prime
delete(primes);
return true;
}
void generateInterpolatedThread() {
Thread* start = new Thread(*glThreads[planThread]->getThread());
Thread* end = new Thread(*glThreads[endThread]->getThread());
numApprox = 10;
vector<Thread*> traj;
traj.resize(numApprox);
traj[0] = start;
traj[traj.size()-1]= end;
vector<VectorXd> controls;
cout << "calling interpolate" << endl;
interpolateThreads(traj, controls);
vector<VectorXd> U;
for (int i = 0; i < traj.size(); i++) {
VectorXd ctrl(12);
ctrl.setZero();
U.push_back(ctrl);
}
Iterative_Control* ic = new Iterative_Control(traj.size(), traj.front()->num_pieces());
int num_iters = 5;
ic->iterative_control_opt(traj, U, num_iters);
vector<vector<Thread*> > thread_visualization_data;
vector<vector<VectorXd> > thread_control_data;
for (int i = 0; i < traj.size(); i++) {
vector<Thread*> tmp;
tmp.push_back(traj[i]);
thread_visualization_data.push_back(tmp);
}
vector<Thread*> control_traj;
control_traj.push_back(new Thread(*glThreads[planThread]->getThread()));
Thread* prevThread = control_traj.front();
for (int i = 1; i < traj.size(); i++) {
Thread* startThread = new Thread(*prevThread);
applyControl(startThread, U[i-1], START_AND_END);
control_traj.push_back(startThread);
prevThread = startThread;
}
thread_visualization_data.push_back(control_traj);
thread_visualization_data.resize(0);
ic->AllFiles_To_Traj(num_iters, thread_visualization_data, thread_control_data);
for (int i=0; i < thread_visualization_data.size(); i++)
{
std::cout << "size: " << thread_visualization_data[i].size() << std::endl;
}
setThreads(thread_visualization_data);
}
void SQPPlanner() {
int num_iters = 3;
Thread* start = new Thread(*glThreads[planThread]->getThread());
Thread* end = new Thread(*glThreads[endThread]->getThread());
numApprox = 100;
vector<Thread*> traj;
traj.resize(numApprox);
traj[0] = new Thread(*start);
traj[traj.size()-1]= new Thread(*end);
vector<VectorXd> controls;
cout << "calling interpolate" << endl;
interpolateThreads(traj, controls);
vector<VectorXd> U;
for (int i = 0; i < traj.size(); i++) {
VectorXd ctrl(12);
ctrl.setZero();
U.push_back(ctrl);
}
Iterative_Control* ic = new Iterative_Control(traj.size(), traj.front()->num_pieces());
cout << "calling SQP" << endl;
ic->iterative_control_opt(traj, U, num_iters);
// need to apply controls that it found
vector<vector<Thread*> > thread_visualization_data;
vector<vector<VectorXd> > thread_control_data;
for (int i = 0; i < traj.size(); i++) {
//vector<Thread*> tmp;
//tmp.push_back(traj[i]);
//thread_visualization_data.push_back(tmp);
vector<VectorXd> motion_wrapper;
motion_wrapper.push_back(U[i]);
thread_control_data.push_back(motion_wrapper);
}
Trajectory_Follower *pathFollower =
new Trajectory_Follower(traj, thread_control_data, start);
pathFollower->control_to_finish();
vector<Thread*> control_traj;
pathFollower->getReachedStates(control_traj);
thread_visualization_data.push_back(traj);
thread_visualization_data.push_back(control_traj);
setThreads(thread_visualization_data);
}
/**
* Brute force version
*
*/
bool brute_setup()
{
size = 1000000;
int initialVal = 0;
cl->init("src/problems/P021xP030/P027.cl","brute");
cl->createReadWriteMemory( sizeof(int),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->setupOpenCLKernelArgs(2,
sizeof(cl_mem), &answer_mem,
sizeof(int), &size);
cl->waitForQueue(); // sync
setThreads(size);
return true;
}
/**
* Brute force version
* Check every single item to see if it's a palindrome!
*/
bool brute_setup()
{
int initialVal = 0;
int count = 900*900; // 100->999 * 100->999
cl->init("src/problems/P001xP010/P004.cl","brute");
cl->createWriteOnlyMemory(sizeof(int),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->setupOpenCLKernelArgs(1,
sizeof(cl_mem), &answer_mem);
cl->waitForQueue(); // sync
setThreads(count);
return true;
}
/**
* Brute force version
* Check every number to see if it's prime, then atomic add it
*/
bool brute_setup()
{
// 1 to 998 for each (because if a is 998, b and c both have to be 1
size = 2000000;
long initialVal = 1; // we will find "1" to be prime and skip 2, so need to offset
cl->init("src/problems/P001xP010/P010.cl","brute");
cl->createWriteOnlyMemory(sizeof(long),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(long),&answer_mem,&initialVal);
cl->setupOpenCLKernelArgs(2,
sizeof(cl_mem), &answer_mem,
sizeof(int), &size); // the size
cl->waitForQueue(); // sync
setThreads(size/2-1);
return true;
}
/**
* Same way to figure out if we're prime, but then do a reduction to add
*/
bool opt_setup()
{
size = 2000000;
long initialVal = 1; // we will find "1" to be prime and skip 2, so need to offset
cl->init("src/problems/P001xP010/P010.cl","optimized");
cl->createWriteOnlyMemory(sizeof(long),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(long),&answer_mem,&initialVal);
cl->setupOpenCLKernelArgs(3,
sizeof(cl_mem), &answer_mem,
sizeof(long)*(1024), NULL, // local scratch space
sizeof(int), &size); // the size
cl->waitForQueue(); // sync
setThreads(size/2-1);
return true;
}
/**
* Brute force version
* Just check every thread ID * 2 + 1 (all odd numbers) to see if it's prime, then
* if it's a divisor, do an atomic max on the answer
*/
bool brute_setup()
{
long number = 600851475143L;
int initialVal = 0;
cl->init("src/problems/P001xP010/P003.cl","brute");
cl->createWriteOnlyMemory(sizeof(int),&answer_mem);
cl->createReadOnlyMemory(sizeof(long),&number_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->transferCPUObjectToGPU(sizeof(long),&number_mem,&number);
cl->setupOpenCLKernelArgs(2,
sizeof(cl_mem), &number_mem,
sizeof(cl_mem), &answer_mem);
cl->waitForQueue(); // sync
setThreads(sqrt(number)/2); // odds that are less than sqrt num
return true;
}
/**
* Brute force version
*
*/
bool opt_setup()
{
size = 14;
int array[120] = { 0 };
getArray(array);
int initialVal = 0;
cl->init("src/problems/P011xP020/P018.cl","optimized");
cl->createReadWriteMemory(sizeof(int),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->createReadWriteMemory(sizeof(int)*120,&array_mem);
cl->transferCPUObjectToGPU(sizeof(int)*120,&array_mem,array);
cl->setupOpenCLKernelArgs(2,
sizeof(cl_mem), &answer_mem,
sizeof(cl_mem), &array_mem);
cl->waitForQueue(); // sync
setThreads(size);
return true;
}
/**
* Brute force version
* All possible combinations of 1,.5,.2,.1,.05,.02 ... 2 is a special case and
* .01 can always be used as filler. We don't include the max of each as that's
* a singular special case (1 2, 2 1's, 4 .5's, etc). So we need to consider
* 1 -> 0,1 {2}
* .5 -> 0,1,2,3 {4}
* .2 -> 0,1,2,3,4,5,6,7,8,9 {10}
* .1 -> {20}
* .05 -> {40}
* .02 -> {100}
* 6.4M combinations
*/
bool brute_setup()
{
size = 6400000;
int initialVal = 7; // 0 of everything is in the combo,
int value_arr[6] = {100, 50, 20, 10, 5, 2};
cl->init("src/problems/P031xP040/P031.cl","brute");
cl->createReadWriteMemory( sizeof(int),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->createReadWriteMemory( sizeof(int)*6,&value_mem);
cl->transferCPUObjectToGPU(sizeof(int)*6,&value_mem,value_arr);
cl->setupOpenCLKernelArgs(3,
sizeof(cl_mem), &answer_mem,
sizeof(cl_mem), &value_mem,
sizeof(int), &size);
cl->waitForQueue(); // sync
setThreads(size);
return true;
}
/**
* Brute force version
*
*/
bool brute_setup()
{
size = 200;
int array[200] = { 0 };
array[size-1] = 1;
int initialVal = 0;
cl->init("src/problems/P011xP020/P020.cl","brute");
cl->createReadWriteMemory(sizeof(int),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(int),&answer_mem,&initialVal);
cl->createReadWriteMemory(sizeof(int)*size,&array_mem);
cl->transferCPUObjectToGPU(sizeof(int)*size,&array_mem,array);
cl->setupOpenCLKernelArgs(3,
sizeof(cl_mem), &answer_mem,
sizeof(cl_mem), &array_mem,
sizeof(int), &size);
cl->waitForQueue(); // sync
setThreads(size);
return true;
}
/**
* Brute force version
*
*/
bool brute_setup()
{
size = 20;
long array[861] = { 0 }; // 2n+1 * n+1
for (int ii = 0; ii < 2*size + 1; ii++)
{
array[ii * (size+1)] = 1;
}
long initialVal = 0;
cl->init("src/problems/P011xP020/P015.cl","brute");
cl->createReadWriteMemory(sizeof(long),&answer_mem);
cl->transferCPUObjectToGPU(sizeof(long),&answer_mem,&initialVal);
cl->createReadWriteMemory(sizeof(long)*(2*size+1)*(size+1),&array_mem);
cl->transferCPUObjectToGPU(sizeof(long)*(2*size+1)*(size+1),&array_mem,array);
cl->setupOpenCLKernelArgs(3,
sizeof(cl_mem), &answer_mem,
sizeof(cl_mem), &array_mem,
sizeof(int), &size);
cl->waitForQueue(); // sync
setThreads(size);
return true;
}
