int main(int argc,char *argv[],char *envp[])
{
int fdA,fdB,fdDelayA,fdDelayB;
int status;
char *bufferA,*bufferB;
pid_t pid;
pagesize = getpagesize();
if ((prepareFile("A",&fdA))
|| (prepareFile("B",&fdB))
|| (prepareFile("DelayA",&fdDelayA))
|| (prepareFile("DelayB",&fdDelayB))
|| (mapBuffer(&bufferA,fdDelayA,fdB))
|| (mapBuffer(&bufferB,fdDelayB,fdA)))
exit(1);
pid = fork();
if (pid == 0)
{
status = startIO(fdA,bufferA);
exit(status);
}
if (pid == -1)
{
exit(1);
}
status = startIO(fdB,bufferB);
exit(status);
}
void VertexUpdateCommand::map()
{
auto ifs = gi::GetGraphicsInterface();
ifs->mapBuffer(m_ctx_vb);
if (m_indices) {
ifs->mapBuffer(m_ctx_ib);
}
}
int
Histogram::setupHistogram()
{
int i = 0;
int status = mapBuffer( dataBuf, data, sizeof(cl_uint) * width * height,
CL_MAP_WRITE_INVALIDATE_REGION);
CHECK_ERROR(status, SDK_SUCCESS, "Failed to map device buffer.(dataBuf)");
for(i = 0; i < width * height; i++)
{
data[i] = rand() % (cl_uint)(binSize);
}
status = unmapBuffer( dataBuf, data );
CHECK_ERROR(status, SDK_SUCCESS, "Failed to unmap device buffer.(dataBuf)");
hostBin = (cl_uint*)malloc(binSize * sizeof(cl_uint));
CHECK_ALLOCATION(hostBin, "Failed to allocate host memory. (hostBin)");
memset(hostBin, 0, binSize * sizeof(cl_uint));
deviceBin = (cl_uint*)malloc(binSize * sizeof(cl_uint));
CHECK_ALLOCATION(deviceBin, "Failed to allocate host memory. (deviceBin)");
memset(deviceBin, 0, binSize * sizeof(cl_uint));
return SDK_SUCCESS;
}
bool compare_images::get_analysis_result()
{
bool return_state;
//! Read results from processing
sync();
float * data = (float *)mapBuffer(opbuff.buffer, 10*sizeof(float),CL_MAP_READ);
//cl_int status = CL_SUCCESS;
//float *data = (float *)malloc(opbuff.mem_size);
//status = clEnqueueReadBuffer(queue,opbuff.buffer,TRUE,0,opbuff.mem_size,data,0,NULL,NULL);
//sync();
float diff_value = 0.0f;
//for(int i=0;i < (kernel_vec.at(0)->globalws[0]); i++)
int i;
for(i=0; i < 10; i++)
{
// printf("Data is %f \n", data[i]);
diff_value = diff_value + data[i];
}
// diff_value = get_rand(0,150);
if(fabs(diff_value) > THRESHOLD)
return_state = ENABLED;
else
return_state = DISABLED;
//printf("Diff is %f \n",diff_value);
return return_state;
}
int
ComputeBench::verifyResults()
{
if (sampleArgs->verify) {
int vecElements = (vec3 == true) ? 3 : vectorSize;
int sizeElement = vectorSize * sizeof (cl_float);
//int readLength = length + (NUM_READS * 1024 / sizeElement) + EXTRA_ELEMENTS;
int status, passStatus;
///////////////////////////////////////////////////////////////////////////////////////////////////
std::cout << "\nVerifying results for KAdd : " << std::endl;
// Map cl_mem outputKadd to host for reading
status = mapBuffer(outputKadd, outputKaddHost, (length * sizeElement), CL_MAP_READ);
CHECK_ERROR(status, SDK_SUCCESS, "Failed to map device buffer.(outputKadd)");
passStatus = 1;
uint* devBuffer = (uint *) outputKaddHost;
for (int i = 0; i < length; i++) {
for (int j = 0; j < vecElements; j++) {
//uint answer = i+j;
uint answer = i;
for (int ii = 0; ii < 1000; ii++) {
//answer ^= ii;
//answer = answer << (ii ) | answer >> (32 - ii );
//answer += ii;
answer += ii;
answer = answer ^ ii;
answer++;
}
// std::cout << " gid:" << i << " vec:" << j << " answer:" << answer << " result:" << devBuffer[j] << std::endl;
if (devBuffer[j] != answer)
passStatus = 0;
}
if (passStatus != 1)
break;
devBuffer += vectorSize;
}
status = unmapBuffer(outputKadd, outputKaddHost);
CHECK_ERROR(status, SDK_SUCCESS, "Failed to unmap device buffer.(outputKadd)");
if (passStatus == 1) {
std::cout << "Passed!\n" << std::endl;
} else {
std::cout << "Failed!\n" << std::endl;
return SDK_FAILURE;
}
}
return SDK_SUCCESS;
}
Result GraphicsInterface::writeBuffer(void *dst_buf, const void *src_mem, size_t write_size, BufferType type)
{
MapContext ctx;
ctx.resource = dst_buf;
ctx.type = type;
ctx.mode = MapMode::Write;
auto res = mapBuffer(ctx);
if (res == Result::OK) {
memcpy(ctx.data_ptr, src_mem, write_size);
res = unmapBuffer(ctx);
}
return res;
}
Result GraphicsInterface::readBuffer(void *dst_mem, void *src_buf, size_t read_size, BufferType type)
{
MapContext ctx;
ctx.resource = src_buf;
ctx.type = type;
ctx.mode = MapMode::Read;
auto res = mapBuffer(ctx);
if (res == Result::OK) {
memcpy(dst_mem, ctx.data_ptr, read_size);
res = unmapBuffer(ctx);
}
return res;
}
// Get a frame from the camera device
void getFrames(int noFrames, int minNoFrames, int* fd, int* imgCaptureType,
int cqual, int fps, int bufferSize)
{
struct v4l2_buffer buf;
struct buffer* bufs;
struct v4l2_requestbuffers reqbuf = getReqBufs(noFrames, minNoFrames, fd);
unsigned int n_buffers, i, ctr = 0;
bool started = FALSE, streamOn = false;
struct lstnode* cNode = allocate(bufferSize);
pthread_mutex_t* mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mutex, NULL);
struct imgDetails det = getFrameFormat(fd); // get video format details
bufs = (struct buffer*)calloc(reqbuf.count, sizeof(*bufs)); // alloc buffers
// If allocation fails
if (bufs == NULL) exitWithError("Could not allocate buffers.");
// Map the memory in kernel space to user space to access video efficiently
for (n_buffers = 0; n_buffers < reqbuf.count; n_buffers++)
{
mapBuffer(reqbuf, n_buffers, buf, bufs, fd);
}
// Queue the request struct to v4l2 to retrieve the video data mem location
for(i = 0; i < reqbuf.count; i++) queueBuffer(i, buf, fd);
streamOn = turnOnCamera(fd, streamOn, imgCaptureType); // turn on camera
while(true) //forever
{
if(!started) // if the write data thread has not yet been started
{
started = TRUE;
createThread(cNode, mutex);
}
for(i = 0; i < reqbuf.count; i++) // for each frame returned
{
usleep(fps); // maintain steady frame rate
pthread_mutex_lock(mutex); // lock pointers
createImage(buf, bufs, i, cNode, fd, det, cqual);
cNode = cNode->next; // work with the next node in the list
printf("|%d|\n", ctr++);
pthread_mutex_unlock(mutex); // release locks
queueBuffer(i, buf, fd); // queue up a new buffer
}
}
for (i = 0; i < reqbuf.count; ++i) // unmap memory
{
munmap(bufs[i].start, bufs[i].length);
}
free(mutex);
free(cNode);
free(bufs);
}
// Test reading from a memory-mapped buffer.
TEST_F(ClBufferTest, mapForReading) {
// initialize buffer with input data
ClBuffer buffer(error, *c, bufferSize, input.data(), clReadOnly);
ASSERT_OK(error);
// memory-map and read data
ClMapBuffer mapBuffer(buffer, CL_MAP_READ);
q->enqueueBlocking(error, mapBuffer); ASSERT_OK(error);
quint8 * bytes = (quint8 * )mapBuffer.pointer();
for (int i = 0; i < (int)bufferSize; ++i)
output[i] = bytes[i];
ClUnmapBuffer unmapBuffer(mapBuffer);
q->enqueue(error, unmapBuffer); ASSERT_OK(error);
ASSERT_EQ(input, output) << "Data read from buffer was not the same as "
"data loaded into it.";
}
// Test writing to a memory-mapped buffer.
TEST_F(ClBufferTest, mapForWriting) {
ClBuffer buffer(error, *c, bufferSize); ASSERT_OK(error);
// memory-map and write to buffer
ClMapBuffer mapBuffer(buffer, CL_MAP_WRITE);
q->enqueueBlocking(error, mapBuffer); ASSERT_OK(error);
quint8 * bytes = (quint8 * )mapBuffer.pointer();
for (int i = 0; i < (int)bufferSize; ++i)
bytes[i] = input[i];
ClUnmapBuffer unmapBuffer(mapBuffer);
q->enqueue(error, unmapBuffer); ASSERT_OK(error);
// read data back
ClReadBuffer readBuffer(buffer, output.data());
q->enqueue(error, readBuffer); ASSERT_OK(error);
q->finish(error); ASSERT_OK(error);
ASSERT_EQ(input, output) << "Data read from buffer was not the same as "
"data written to it.";
}
int
Histogram::calculateHostBin()
{
int status = mapBuffer( dataBuf, data, sizeof(cl_uint) * width * height,
CL_MAP_READ);
CHECK_ERROR(status, SDK_SUCCESS,
"Failed to map device buffer.(dataBuf in calcHostBin)");
for(int i = 0; i < height; ++i)
{
for(int j = 0; j < width; ++j)
{
hostBin[data[i * width + j]]++;
}
}
status = unmapBuffer( dataBuf, data );
CHECK_ERROR(status, SDK_SUCCESS,
"Failed to unmap device buffer.(dataBuf in calcHostBin)");
return SDK_SUCCESS;
}
int
Histogram::runCLKernels(void)
{
cl_int status;
cl_int eventStatus = CL_QUEUED;
status = this->setWorkGroupSize();
CHECK_ERROR(status, SDK_SUCCESS, "setKernelWorkGroupSize() failed");
// whether sort is to be in increasing order. CL_TRUE implies increasing
status = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void*)&dataBuf);
CHECK_OPENCL_ERROR(status, "clSetKernelArg failed. (dataBuf)");
status = clSetKernelArg(kernel, 1, groupSize * binSize * sizeof(cl_uchar),
NULL);
CHECK_OPENCL_ERROR(status, "clSetKernelArg failed. (local memory)");
status = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void*)&midDeviceBinBuf);
CHECK_OPENCL_ERROR(status, "clSetKernelArg failed. (deviceBinBuf)");
// Enqueue a kernel run call.
cl_event ndrEvt;
status = clEnqueueNDRangeKernel(
commandQueue,
kernel,
1,
NULL,
&globalThreads,
&localThreads,
0,
NULL,
&ndrEvt);
CHECK_OPENCL_ERROR(status, "clEnqueueNDRangeKernel failed.");
status = clFlush(commandQueue);
CHECK_OPENCL_ERROR(status, "clFlush failed.");
status = waitForEventAndRelease(&ndrEvt);
CHECK_ERROR(status, SDK_SUCCESS, "WaitForEventAndRelease(ndrEvt1) Failed");
status = mapBuffer( midDeviceBinBuf, midDeviceBin,
subHistgCnt * binSize * sizeof(cl_uint), CL_MAP_READ);
CHECK_ERROR(status, SDK_SUCCESS,
"Failed to map device buffer.(midDeviceBinBuf)");
// Clear deviceBin array
memset(deviceBin, 0, binSize * sizeof(cl_uint));
// Calculate final histogram bin
for(int i = 0; i < subHistgCnt; ++i)
{
for(int j = 0; j < binSize; ++j)
{
deviceBin[j] += midDeviceBin[i * binSize + j];
}
}
status = unmapBuffer( midDeviceBinBuf, midDeviceBin);
CHECK_ERROR(status, SDK_SUCCESS,
"Failed to unmap device buffer.(midDeviceBinBuf)");
return SDK_SUCCESS;
}
bool Magic3D::TextData::update(Object* object)
{
if (object)
{
}
Renderer* renderer = Renderer::getInstance();
Font* font = getFont();
std::vector<float> lines;
if (!font)
{
return false;
}
float fsize = (textSize / 512.0f) / font->getLineHeightInPixels();
float lineHeight = fsize * (font->getLineHeightInPixels() + 2.0f);
int quadCount = getVerticesCount() / 4;
if (quadCount < (int)text.size() - lastReturns)
{
lastReturns = 0;
size_t tsize = text.size();
for (size_t i = 0; i < tsize; i++)
{
if (text.at(i) == '\n')
{
lastReturns++;
continue;
}
else if (renderer->hasMapBuffer() || ((int)i >= quadCount))
{
addQuad(0.0f, 0.0f, 1.0f, 1.0f, eAXIS_Z, false);
}
}
createVbo();
quadCount = getVerticesCount() / 4;
}
width = 0.0f;
height = lineHeight;
if (getVerticesCount() > 0)
{
int quad = -1;
float startX = 0.0f;
float startY = 0.0f;
float* buffer = mapBuffer();
int lastIndex = 0;
size_t tsize = text.size();
for (size_t i = 0; i < tsize; i++)
{
int index = text.at(i);
if (index < 0)
{
index = 256 + index;
}
FontChar* fchar = font->getChar(index);
if (text.at(i) == '\n')
{
lines.push_back(startX);
if (width < startX)
{
width = startX;
}
startX = 0.0f;
if (invert)
{
startY -= lineHeight;
}
else
{
startY += lineHeight;
}
height += lineHeight;
continue;
}
else
{
quad++;
}
float texX = fchar->x;
float texY = 1.0f - fchar->y;
float texW = fchar->width;
float texH = fchar->height;
float cwidth = fchar->width * font->getTextureWidth() * fsize;
float cheight = fchar->height * font->getTextureHeight() * fsize;
float coffsetX = fchar->offsetX * font->getTextureWidth() * fsize;
float coffsetY = fchar->offsetY * font->getTextureHeight() * fsize;
float cadvanceX = fchar->advanceX * font->getTextureWidth() * fsize;
float ckernel = 0.0f;
std::map<int, float>::const_iterator k = fchar->kernel.find(lastIndex);
if (k != fchar->kernel.end())
{
ckernel = (*k).second * fsize;
}
setQuad(buffer, quad, startX + coffsetX + ckernel, startY + coffsetY * 0.5f, cwidth, cheight);
if (invert)
{
setQuadTexture(buffer, quad, texX, texY - texH, texW, -texH);
}
else
{
setQuadTexture(buffer, quad, texX, texY, texW, texH);
}
startX += cadvanceX;
lastIndex = index;
}
quad++;
for (int i = quad; i < quadCount; i++)
{
setQuad(buffer, i, startX, startY, 0.0f, 0.0f);
}
lines.push_back(startX);
if (width < startX)
{
width = startX;
}
width += (2.0f * fsize);
quad = 0;
int line = 0;
tsize = text.size();
for (size_t i = 0; i < tsize; i++)
{
if (text.at(i) != '\n')
{
float w = width * -0.5f;
float diff = line < (int)lines.size() ? lines.at(line) : width;
switch (textAlignment)
{
case eHORIZONTAL_ALIGN_CENTER: w += (width - diff) * 0.5f; break;
case eHORIZONTAL_ALIGN_RIGHT: w += (width - diff); break;
default: break;
}
if (invert)
{
moveQuad(buffer, quad, w, height * 0.5f - lineHeight, 0.0f);
}
else
{
moveQuad(buffer, quad, w, height * -0.5f, 0.0f);
}
quad++;
}
else
{
line++;
}
}
unmapBuffer();
}
changed = false;
box.corners[0] = Vector3(-width * 0.5f, -height * 0.5f, 0.0f);
box.corners[1] = Vector3(width * 0.5f, height * 0.5f, 0.0f);
return true;
}
bool DisplayPlane::setDataBuffer(uint32_t handle)
{
DataBuffer *buffer;
BufferMapper *mapper;
ssize_t index;
bool ret;
bool isCompression;
BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
RETURN_FALSE_IF_NOT_INIT();
ALOGTRACE("handle = %#x", handle);
if (!handle) {
WLOGTRACE("invalid buffer handle");
return false;
}
// do not need to update the buffer handle
if (mCurrentDataBuffer != handle)
mUpdateMasks |= PLANE_BUFFER_CHANGED;
// if no update then do Not need set data buffer
if (!mUpdateMasks)
return true;
buffer = bm->lockDataBuffer(handle);
if (!buffer) {
ELOGTRACE("failed to get buffer");
return false;
}
mIsProtectedBuffer = GraphicBuffer::isProtectedBuffer((GraphicBuffer*)buffer);
isCompression = GraphicBuffer::isCompressionBuffer((GraphicBuffer*)buffer);
// map buffer if it's not in cache
index = mDataBuffers.indexOfKey(buffer->getKey());
if (index < 0) {
VLOGTRACE("unmapped buffer, mapping...");
mapper = mapBuffer(buffer);
if (!mapper) {
ELOGTRACE("failed to map buffer %#x", handle);
bm->unlockDataBuffer(buffer);
return false;
}
} else {
VLOGTRACE("got mapper in saved data buffers and update source Crop");
mapper = mDataBuffers.valueAt(index);
}
// always update source crop to mapper
mapper->setCrop(mSrcCrop.x, mSrcCrop.y, mSrcCrop.w, mSrcCrop.h);
mapper->setIsCompression(isCompression);
// unlock buffer after getting mapper
bm->unlockDataBuffer(buffer);
buffer = NULL;
ret = setDataBuffer(*mapper);
if (ret) {
mCurrentDataBuffer = handle;
// update active buffers
updateActiveBuffers(mapper);
}
return ret;
}
