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