void computeDescriptorsLane(void *pixels, int depth, int width, int height, VertexBufferObject &points, DescriptorData &descriptors)
{
unsigned char *srcBuffer;
unsigned char *dstBuffer;
cudaMalloc( (void**) &srcBuffer, sizeof(unsigned char)*depth*width*height);
cudaMemcpy( srcBuffer, pixels, sizeof(unsigned char)*depth*width*height, cudaMemcpyHostToDevice );
cudaMalloc((void**) &dstBuffer, sizeof(unsigned char)*depth*width*height*2);
// convert to RGB
cudaYCbYCrToY( (uchar4*)dstBuffer, (uchar4*)srcBuffer, width*2, height);
std::cout << "Passed cudaYCbYCrToY" << std::endl;
// convert to 1 plane float cuda
//float *yBuffer;
//cudaMalloc((void**)&yBuffer, sizeof(float)*width*2*height);
UInt2 imgSize(1920,1080);
CudaImageBuffer<float> m_satImage;
allocBuffer(m_satImage, imgSize);
cudaRGBAtoCuda((float*)m_satImage, (uchar4*)dstBuffer, width*2, height, width*2);
std::cout << "Passed cudaRGBAtoCuda" << std::endl;
convertToIntegral(m_satImage);
std::cout << "Passed convertToIntegral" << std::endl;
CudaImageBuffer<float> m_hesImage;
allocBuffer(m_hesImage, imgSize);
HessianData m_hessianData;
m_hessianData.allocImages(imgSize);
computeHessianDet( m_satImage, m_hesImage, m_hessianData );
std::cout << "Passed computeHessianDet" << std::endl;
computeNonMaxSuppression( m_hesImage, m_hessianData );
std::cout << "Passed computeNonMaxSuppression" << std::endl;
collectHessianPoints( m_hessianData, descriptors);
std::cout << "Passed collectHessianPoint" << std::endl;
computeDescriptors( m_satImage, descriptors);
std::cout << "Passed computeDescriptors" << std::endl;
//collectPoints( descriptors, points, imgSize );
// free memory
m_hessianData.freeImages();
releaseBuffer(m_hesImage);
releaseBuffer(m_satImage);
cudaFree(srcBuffer);
cudaFree(dstBuffer);
}
StompSocket::StompSocket():
_pBuffer(0),
_pNext(0),
_pEnd(0)
{
allocBuffer();
}
StringBuffer::StringBuffer(const StringBuffer &sb) : m_hHeap(sb.m_hHeap), m_strLen(0)
{
m_pStr = allocBuffer(sb.m_bufferSize);
_tcsncpy_s(m_pStr, m_bufferSize, sb.m_pStr, sb.m_strLen);
int i = -1;
while(m_pStr[++i] != 0x00 && i < static_cast<int>(m_allocSize / sizeof(TCHAR)))++m_strLen;
}
void test_prima_un_produttore_poi_un_consumatore_concorrenti(void) {
pthread_t prod;
pthread_t cons;
buffer buf = allocBuffer(1);
numero_produttori_attivi = 1;
pthread_create(&prod, NULL, &produttore_bloccante_p1, buf);
numero_consumatori_attivi = 1;
pthread_create(&cons, NULL, &consumatore_bloccante_c1, buf);
pthread_join(cons, NULL);
pthread_join(prod, NULL);
CU_ASSERT_EQUAL(numero_consumatori_attivi, 0);
CU_ASSERT_EQUAL(numero_produttori_attivi, 0);
CU_ASSERT_PTR_EQUAL(buf->list_cell_full->buffer_cell_head, NULL);
freeBuffer(buf);
}
void test_put_bloccante_buffer_pieno(void) {
pthread_t prod;
buffer buf = allocBuffer(1);
void *primo_messaggio = (void *) 8;
void *secondo_messaggio = (void *) 12;
putInBuffer_blocking(buf, primo_messaggio);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, primo_messaggio);
numero_produttori_attivi = 1;
pthread_create(&prod, NULL, &produttore_bloccante_p1, buf);
getFromBuffer_blocking(buf);
pthread_join(prod, NULL);
CU_ASSERT_EQUAL(numero_produttori_attivi, 0);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, secondo_messaggio);
freeBuffer(buf);
}
static void RemoteTransformer_Destroy(Transformer_t* transformer)
{
RemoteTransformer_t *remoteTransformer = (RemoteTransformer_t *) transformer;
EMBX_ERROR err;
remoteTransformer->super.info->referenceCount--;
/* clean up the buffer cache (allocated during execution) */
while (remoteTransformer->bufferCache) {
void *buf = allocBuffer(remoteTransformer, 1);
if (buf) {
EMBX_ERROR err;
err = EMBX_Free(buf);
MME_Assert(EMBX_SUCCESS == err);
}
}
if (remoteTransformer->adminPort) {
err = EMBX_ClosePort(remoteTransformer->adminPort);
MME_Assert(EMBX_SUCCESS == err); /* no recovery possible */
}
EMBX_OS_EVENT_DESTROY(&remoteTransformer->terminateWasReplied);
EMBX_OS_MUTEX_DESTROY(&remoteTransformer->commandSlotLock);
EMBX_OS_MemFree(remoteTransformer->commandSlots);
EMBX_OS_MemFree(remoteTransformer);
}
Buffer::Buffer(size_t bufferSize)
: bufferSize_(bufferSize),
current_(NULL),
unusedDataSize_(0)
{
buffer_ = allocBuffer(bufferSize_);
}
uint8_t* ArgumentEncoder::grow(unsigned alignment, size_t size)
{
size_t alignedSize = roundUpToAlignment(m_bufferSize, alignment);
if (alignedSize + size > m_bufferCapacity) {
size_t newCapacity = roundUpToAlignment(m_bufferCapacity * 2, 4096);
while (newCapacity < alignedSize + size)
newCapacity *= 2;
uint8_t* newBuffer = static_cast<uint8_t*>(allocBuffer(newCapacity));
if (!newBuffer)
CRASH();
memcpy(newBuffer, m_buffer, m_bufferSize);
if (m_buffer != m_inlineBuffer)
freeBuffer(m_buffer, m_bufferCapacity);
m_buffer = newBuffer;
m_bufferCapacity = newCapacity;
}
m_bufferSize = alignedSize + size;
m_bufferPointer = m_buffer + alignedSize + size;
return m_buffer + alignedSize;
}
void test_molti_consumatori_su_buffer_inizialmente_pieno(void) {
pthread_t cons[5];
int i;
void *messaggio = (void *) 10;
buffer buf = allocBuffer(1);
putInBuffer_blocking(buf, messaggio);
numero_consumatori_attivi = 5;
for (i = 0; i < 5; i++) {
pthread_create(&cons[i], NULL, &consumatore_non_bloccante_c2, buf);
}
for (i = 0; i < 5; i++) {
pthread_join(cons[i], NULL);
}
CU_ASSERT_EQUAL(numero_consumatori_attivi, 0);
CU_ASSERT_PTR_EQUAL(buf->list_cell_full->buffer_cell_head, NULL);
freeBuffer(buf);
}
void test_molti_produttori_su_buffer_inizialmente_vuoto(void) {
pthread_t prod[5];
int i;
void *messaggio = (void *) 3;
buffer buf = allocBuffer(1);
numero_produttori_attivi = 5;
for (i = 0; i < 5; i++) {
pthread_create(&prod[i], NULL, &produttore_non_bloccante_p2, buf);
}
for (i = 0; i < 5; i++) {
pthread_join(prod[i], NULL);
}
CU_ASSERT_EQUAL(numero_produttori_attivi, 0);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, messaggio);
freeBuffer(buf);
}
char *AuxDataPacket::getBuffer()
{
if (!m_buffer) {
allocBuffer(getSize());
char *target = m_buffer;
FlushHeader2Buffer(target);
Add2Buffer(target, (char) m_version);
Add2Buffer(target, (char) m_headerLen);
Add2Buffer(target, (char) m_opCode);
Add2Buffer(target, (char) m_priority);
Add2Buffer(target, (long) m_prune);
Add2Buffer(target, (char) m_status);
Add2Buffer(target, (char) 0);
Add2Buffer(target, m_segmentLength);
Add2Buffer(target, (char) m_type[0]);
Add2Buffer(target, (char) m_type[1]);
Add2Buffer(target, (char) m_type[2]);
Add2Buffer(target, (char) m_type[3]);
Add2Buffer(target, m_itemNumber);
Add2Buffer(target, m_itemID);
Add2Buffer(target, m_itemLength);
Add2Buffer(target, m_segmentOffset);
Add2Buffer(target, (char *) m_data, m_itemLength);
}
return m_buffer;
}
DialogSocket::DialogSocket():
_pBuffer(0),
_pNext(0),
_pEnd(0)
{
allocBuffer();
}
StompSocket::StompSocket(const Socket& socket):
StreamSocket(socket),
_pBuffer(0),
_pNext(0),
_pEnd(0)
{
allocBuffer();
}
DialogSocket::DialogSocket(const DialogSocket& socket):
StreamSocket(socket),
_pBuffer(0),
_pNext(0),
_pEnd(0)
{
allocBuffer();
}
DialogSocket::DialogSocket(const SocketAddress& address):
StreamSocket(address),
_pBuffer(0),
_pNext(0),
_pEnd(0)
{
allocBuffer();
}
void test_get_non_bloccante_buffer_vuoto(void) {
buffer buf = allocBuffer(1);
CU_ASSERT_EQUAL(getFromBuffer_not_blocking(buf), (void *) BUFFER_VUOTO);
freeBuffer(buf);
}
void test_put_bloccante_buffer_vuoto(void) {
buffer buf = allocBuffer(1);
void *messaggio = (void *) 7;
putInBuffer_blocking(buf, messaggio);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, messaggio);
freeBuffer(buf);
}
int Buffer::ResizeBuffer(size_t bufferSize) {
LOG(LOG_INFO, "Resize buffer");
char *oldBuffer = buffer_;
buffer_ = allocBuffer(bufferSize);
assert(buffer_);
if (!buffer_)
{
return EC_MEMFAIL;
}
bufferSize_ = bufferSize;
memcpy(buffer_, current_, unusedDataSize_);
current_ = buffer_;
free(oldBuffer);
return EC_SUCCESS;
}
void test_get_bloccante_buffer_pieno(void) {
buffer buf = allocBuffer(1);
void *messaggio = (void *) 23;
putInBuffer_blocking(buf, messaggio);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, messaggio);
CU_ASSERT_EQUAL(getFromBuffer_blocking(buf), messaggio);
CU_ASSERT_PTR_EQUAL(buf->list_cell_full->buffer_cell_head, NULL);
freeBuffer(buf);
}
static MME_ERROR RemoteTransformer_AbortCommand(Transformer_t* transformer, MME_CommandId_t commandId)
{
RemoteTransformer_t *remoteTransformer = (RemoteTransformer_t *) transformer;
EMBX_ERROR err;
EMBX_VOID *buffer;
TransformerAbortMessage *message;
CommandSlot_t *slot;
/* TODO: shouldn't this be asserted! */
if (!remoteTransformer->sendPort.valid) {
MME_Info(MME_INFO_TRANSFORMER, (DEBUG_ERROR_STR "MME port does not exist\n"));
return MME_DRIVER_NOT_INITIALIZED;
}
/* confirm that the command is actually pending on the companion before we
* issue the abort */
slot = &(remoteTransformer->commandSlots[MME_CMDID_GET_COMMAND(commandId)]);
if (slot->status != MME_RUNNING || commandId != slot->command->CmdStatus.CmdId) {
return MME_INVALID_ARGUMENT;
}
/* Allocate an abort message and send it to the companion side, which disposes the buffer */
buffer = allocBuffer(remoteTransformer, sizeof(TransformerAbortMessage));
if (0 == buffer) {
return MME_NOMEM;
}
/* initialize the message */
message = (TransformerAbortMessage *) buffer;
message->id = TMESSID_ABORT;
message->messageSize = sizeof(TransformerAbortMessage);
message->commandId = commandId;
/* post the message */
err = EMBX_SendMessage(remoteTransformer->sendPort.port, message, message->messageSize);
if (err != EMBX_SUCCESS) {
/* If sending the message did not work, there is nothing we can do. */
MME_Info(MME_INFO_TRANSFORMER, (DEBUG_ERROR_STR "EMBX_SendMessage(TransformerAbortMessage) failed, error=%d\n", err));
freeBuffer(remoteTransformer, buffer);
return MME_NOMEM;
}
/* success does not indicate the command has been aborted only
* that the request has been sent
*/
return MME_SUCCESS;
}
void MLMultiContainer::compile()
{
const int copies = (int)mCopies.size();
for(int i=0; i<copies; i++)
{
getCopyAsContainer(i)->compile();
}
// MLProcContainer's outputs are allocated in compile(). We do a minimal verison here.
int outs = getNumOutputs();
for(int i=0; i<outs; ++i)
{
MLSignal& newSig = *allocBuffer();
setOutput(i + 1, newSig);
}
}
void test_put_non_bloccante_buffer_pieno(void) {
buffer buf = allocBuffer(1);
void *primo_messaggio = (void *) 2;
void *secondo_messaggio = (void *) 3;
putInBuffer_blocking(buf, primo_messaggio);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, primo_messaggio);
CU_ASSERT_EQUAL(putInBuffer_not_blocking(buf, secondo_messaggio), BUFFER_PIENO);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, primo_messaggio);
freeBuffer(buf);
}
/*
Get first vCard list buffer
*/
bool folderGetFirstListBuffer(uint16 pStartPos)
{
bool lFinished = FALSE;
uint16 lToCopy;
DEBUG(("folderGetFirstListBuffer\n"));
/* Setup buffer */
if (!allocBuffer(PBAPS_MIN_BUFFER_SIZE))
{
DEBUG((" Cannot Allocate Buffer\n"));
Panic();
}
/* Open phonebook */
if (!pbaOpenPhonebook(the_app->folderData.current))
{
DEBUG((" Cannot open phonebook\n"));
Panic();
}
/* Copy preamble to buffer */
lToCopy = (the_app->buffer.sizeBuffer <= sizeof(gVCardListHeader)) ? the_app->buffer.sizeBuffer : sizeof(gVCardListHeader);
memcpy(the_app->buffer.buffer, gVCardListHeader, lToCopy);
the_app->buffer.freeSpace -= lToCopy;
the_app->buffer.nextPos += lToCopy;
the_app->buffer.used += lToCopy;
the_app->folderData.listLeft = sizeof(gVCardListHeader) - lToCopy;
/* Ensure we start with a search */
the_app->folderData.sentCurrent = TRUE;
if (pStartPos>0)
{
pbaGotoEntry(pStartPos);
}
if (the_app->buffer.freeSpace >= 0)
{
lFinished = folderFillBuffer();
}
return lFinished;
}
void test_get_non_bloccante_buffer_pieno(void) {
buffer buf = allocBuffer(1);
void *messaggio = (void *) 9;
putInBuffer_blocking(buf, messaggio);
CU_ASSERT_EQUAL(buf->list_cell_full->buffer_cell_head->cell_pointer, messaggio);
CU_ASSERT_EQUAL(getFromBuffer_not_blocking(buf), messaggio);
/*
* Per verificare che il buffer sia vuoto devo controllare che ls lista piene sia vuota
*/
CU_ASSERT_PTR_EQUAL(buf->list_cell_full->buffer_cell_head, NULL);
freeBuffer(buf);
}
static MME_ERROR createTerminateMessage(RemoteTransformer_t* remoteTransformer, int messageSize, EMBX_VOID ** buffer)
{
TransformerTerminateMessage *message;
messageSize += sizeof(TransformerTerminateMessage);
*buffer = allocBuffer(remoteTransformer, messageSize);
if (buffer) {
message = (TransformerTerminateMessage *) (*buffer);
message->id = TMESSID_TERMINATE;
message->messageSize = messageSize;
message->mmeHandle = remoteTransformer->mmeHandle;
message->result = MME_SUCCESS;
return MME_SUCCESS;
}
return MME_NOMEM;
}
void test_get_bloccante_buffer_vuoto(void) {
pthread_t cons;
buffer buf = allocBuffer(1);
void *messaggio = (void *) 32;
numero_consumatori_attivi = 1;
pthread_create(&cons, NULL, &consumatore_bloccante_c1, buf);
putInBuffer_blocking(buf, messaggio);
pthread_join(cons, NULL);
CU_ASSERT_EQUAL(numero_consumatori_attivi, 0);
CU_ASSERT_PTR_EQUAL(buf->list_cell_full->buffer_cell_head, NULL);
freeBuffer(buf);
}
static MME_ERROR createInitMessage(RemoteTransformer_t* remoteTransformer, const char* name,
MME_TransformerInitParams_t* params, EMBX_VOID** buffer)
{
TransformerInitMessage *message;
unsigned paramsSize;
int messageSize;
MME_Assert(params->StructSize == sizeof(MME_TransformerInitParams_t));
messageSize = sizeof(TransformerInitMessage);
paramsSize = params->TransformerInitParamsSize;
messageSize += paramsSize;
message = allocBuffer(remoteTransformer, messageSize);
if (0 == message ) {
return MME_NOMEM;
}
message->id = TMESSID_INIT;
message->messageSize = messageSize;
message->priority = params->Priority;
message->result = MME_SUCCESS;
MME_Assert(strlen(name) < MME_MAX_TRANSFORMER_NAME);
strcpy(message->transformerType, name);
MME_Assert(strlen(remoteTransformer->replyPort.name) < EMBX_MAX_PORT_NAME);
strcpy(message->portName, remoteTransformer->replyPort.name);
/* Copy TransformerInitParams data */
/* TODO: these should be byte swapped on a big endian machine */
memcpy((void *) (message + 1), params->TransformerInitParams_p, paramsSize);
*buffer = message;
return MME_SUCCESS;
}
void CppSQLite3Binary::setBinary(const unsigned char* pBuf, int nLen)
{
mpBuf = allocBuffer(nLen);
memcpy(mpBuf, pBuf, nLen);
}
void* bridgeThread(void* arg)
{
int remoteSocket = (int)(intptr_t) arg;
if(0 != geteuid()) // run only as non-root
{
char* localPort = pGetConfig()->sslPort;
char* localHost = pGetConfig()->sslHostname;
struct timeval sshDetectTimeout = { pGetConfig()->timeOut , 0 }; // 2 sec
struct timeval sslConnectionTimeout = { 120, 0 }; // 120 sec
struct timeval connectionTimeout = { 7200,0 }; // 2 hours
fd_set readFds;
int rc;
// test for ssl/ssh connection
FD_ZERO(&readFds);
FD_SET(remoteSocket, &readFds);
rc = select(remoteSocket+1, &readFds, 0, 0, &sshDetectTimeout);
if(rc != -1)
{
struct addrinfo* addrInfo;
struct addrinfo* addrInfoBase;
int localSocket;
char prefetchBuffer[3];
ssize_t prefetchReadCount = 0;
if(rc == 0) // timeout -> ssh connection
{
localPort = pGetConfig()->sshPort;
localHost = pGetConfig()->sshHostname;
}
else // ssl and SSH protocol 2 connections
{
prefetchReadCount = recv(remoteSocket, prefetchBuffer, sizeof(prefetchBuffer), 0);
if(memcmp("SSH",prefetchBuffer, sizeof(prefetchBuffer)) == 0)
{
syslog(LOG_DEBUG,
"%s(): incomming SSH protocol 2 connection detected ...",
__FUNCTION__);
localPort = pGetConfig()->sshPort;
localHost = pGetConfig()->sshHostname;
}
else
{
connectionTimeout.tv_sec= sslConnectionTimeout.tv_sec;
}
}
resolvAddress(localHost, localPort, &addrInfo);
addrInfoBase = addrInfo; // need for delete
while(addrInfo != NULL)
{
localSocket = socket(addrInfo->ai_family,
addrInfo->ai_socktype,
addrInfo->ai_protocol);
if(localSocket >= 0)
{
if(connect(localSocket,
addrInfo->ai_addr,
addrInfo->ai_addrlen) != -1)
break;
else
close(localSocket);
}
addrInfo = addrInfo->ai_next;
}
if(addrInfoBase != NULL)
freeaddrinfo(addrInfoBase);
if (addrInfo != NULL) /* address succeeded */
{
struct bufferList_t* pBufferListElement = allocBuffer();
// test Buffer
if(NULL != pBufferListElement &&
NULL != pBufferListElement->buffer)
{
if(rc != 0) // no timeout
{
if(writeall(localSocket, prefetchBuffer, prefetchReadCount) &&
redirectData(remoteSocket, localSocket, pBufferListElement->buffer) > 0)
{
rc = 0; // handle as normal connection
}
}
if(rc == 0)
{
bridgeConnection(remoteSocket, localSocket,
pBufferListElement->buffer, &connectionTimeout);
}
close(localSocket);
freeBuffer(pBufferListElement);
}
else // invalid Buffer Structure
{
syslog(LOG_ERR, "%s(): invalid Bufferpointer", __FUNCTION__);
}
}
else
{
perror("unable to establish the client connection");
}
}
}
else
{
syslog(LOG_ERR,
"%s() threads running only as non-root", __FUNCTION__);
}
close(remoteSocket);
modifyClientThreadCounter(-1);
return NULL; // no receiver for return code
}
RecordBuffer* DbCreatorsList::makeBuffer(thread_db* tdbb)
{
MemoryPool* const pool = tdbb->getTransaction()->tra_pool;
allocBuffer(tdbb, *pool, rel_sec_db_creators);
return getData(rel_sec_db_creators);
}
