// Detaches from the data source and rebuilds the options.
void ElementFormControlDataSelect::OnDataSourceDestroy(DataSource* _data_source)
{
if (data_source == _data_source)
{
data_source->DetachListener(this);
data_source = NULL;
data_table = "";
BuildOptions();
}
}
// If a new data source has been set on the control, this will attach to it and build the initial
// options.
void ElementFormControlDataSelect::OnUpdate()
{
if (!initialised)
{
initialised = true;
if (ParseDataSource(data_source, data_table, GetAttribute< Rocket::Core::String >("source", "")))
{
data_source->AttachListener(this);
BuildOptions();
}
}
}
// Checks for changes to the data source or formatting attributes.
void ElementFormControlDataSelect::OnAttributeChange(const Core::AttributeNameList& changed_attributes)
{
ElementFormControlSelect::OnAttributeChange(changed_attributes);
if (changed_attributes.find("source") != changed_attributes.end())
{
if (data_source != NULL)
data_source->DetachListener(this);
initialised = false;
}
else if (changed_attributes.find("fields") != changed_attributes.end() ||
changed_attributes.find("valuefield") != changed_attributes.end() ||
changed_attributes.find("formatter") != changed_attributes.end())
{
BuildOptions();
}
}
Settings()
{
BuildOptions();
}
// Rebuilds the available options from the data source.
void ElementFormControlDataSelect::OnRowChange(DataSource* ROCKET_UNUSED(data_source), const Rocket::Core::String& table)
{
if (table == data_table)
BuildOptions();
}
// Rebuilds the available options from the data source.
void ElementFormControlDataSelect::OnRowChange(DataSource* ROCKET_UNUSED(data_source), const Rocket::Core::String& table, int ROCKET_UNUSED(first_row_changed), int ROCKET_UNUSED(num_rows_changed))
{
if (table == data_table)
BuildOptions();
}
int main(int argc, char **argv)
{
TS ts; //Time stepper
Vec soln; //Holds the solution vector, including all the primitive
//variables.
DM dmda; //Manages the computational grid and parallelization.
int X1Start, X2Start;
int X1Size, X2Size;
PetscInitialize(&argc, &argv, PETSC_NULL, help);
// Create the computational domain.
DMDACreate2d(PETSC_COMM_WORLD,
DM_BOUNDARY_GHOSTED, DM_BOUNDARY_GHOSTED,
DMDA_STENCIL_STAR,
N1, N2,
PETSC_DECIDE, PETSC_DECIDE,
DOF, NG, PETSC_NULL, PETSC_NULL, &dmda);
// When running in parallel, each process computes from
// [X1Start, X1Start+X1Size] x [X2Start, X2Start+X2Size]
DMDAGetCorners(dmda,
&X1Start, &X2Start, NULL,
&X1Size, &X2Size, NULL);
// Create the solution vector.
DMCreateGlobalVector(dmda, &soln);
// Create the time stepper and link it to the computational grid and the
// residual evaluation function.
TSCreate(PETSC_COMM_WORLD, &ts);
TSSetDM(ts, dmda);
TSSetIFunction(ts, PETSC_NULL, ComputeResidual, NULL);
// OpenCL boilerplate code.
clErr = cl::Platform::get(&platforms);
CheckCLErrors(clErr, "cl::Platform::get");
// Select computation device here.
clErr = platforms.at(1).getDevices(CL_DEVICE_TYPE_CPU, &devices);
CheckCLErrors(clErr, "cl::Platform::getDevices");
context = cl::Context(devices, NULL, NULL, NULL, &clErr);
CheckCLErrors(clErr, "cl::Context::Context");
queue = cl::CommandQueue(context, devices.at(0), 0, &clErr);
CheckCLErrors(clErr, "cl::CommandQueue::CommandQueue");
std::ifstream sourceFile("computeresidual.cl");
std::string sourceCode((std::istreambuf_iterator<char>(sourceFile)),
std::istreambuf_iterator<char>());
cl::Program::Sources source(1, std::make_pair(sourceCode.c_str(),
sourceCode.length()+1));
program = cl::Program(context, source, &clErr);
CheckCLErrors(clErr, "cl::Program::Program");
// Pass in constants to the OpenCL kernel as compiler switches. This is an
// efficient way to handle constants such as domain sizes in OpenCL.
std::string BuildOptions("\
-D X1_SIZE=" +
std::to_string(X1Size) +
" -D X2_SIZE=" +
std::to_string(X2Size) +
" -D TOTAL_X1_SIZE=" +
std::to_string(X1Size+2*NG) +
" -D TOTAL_X2_SIZE=" +
std::to_string(X2Size+2*NG));
// Compile the OpenCL program and extract the kernel.
PetscScalar start = std::clock();
clErr = program.build(devices, BuildOptions.c_str(), NULL, NULL);
const char *buildlog = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(
devices.at(0),
&clErr).c_str();
PetscPrintf(PETSC_COMM_WORLD, "%s\n", buildlog);
CheckCLErrors(clErr, "cl::Program::build");
PetscScalar end = std::clock();
PetscScalar time = (end - start)/(PetscScalar)CLOCKS_PER_SEC;
PetscPrintf(PETSC_COMM_WORLD,
"Time taken for kernel compilation = %f\n", time);
kernel = cl::Kernel(program, "ComputeResidual", &clErr);
CheckCLErrors(clErr, "cl::Kernel::Kernel");
// How much memory is the kernel using?
cl_ulong localMemSize = kernel.getWorkGroupInfo<CL_KERNEL_LOCAL_MEM_SIZE>(
devices.at(0), &clErr);
cl_ulong privateMemSize = kernel.getWorkGroupInfo<CL_KERNEL_PRIVATE_MEM_SIZE>(
devices.at(0), &clErr);
printf("Local memory used = %llu\n", (unsigned long long)localMemSize);
printf("Private memory used = %llu\n", (unsigned long long)privateMemSize);
// Set initial conditions.
InitialCondition(ts, soln);
TSSetSolution(ts, soln);
TSSetType(ts, TSTHETA);
TSSetFromOptions(ts);
// Finally solve! All time stepping options can be controlled from the
// command line.
TSSolve(ts, soln);
// Delete the data structures in the following order.
DMDestroy(&dmda);
VecDestroy(&soln);
TSDestroy(&ts);
PetscFinalize();
return(0);
}