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); }
/*-------------------------------------------------------------------- * DESCRIPTION (Private -- phase out 5/4/95) * Set the name of the file to associate with the profile. * If the Name is NULL no file will be associated with the profile. * * AUTHOR * lsh * * DATE CREATED * Octorber 22, 1993 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpProfileSetFileName ( SpProfile_t Profile, char FAR *FileName) { char FAR *fileName; SpProfileData_t FAR *ProfileData; /* convert profile handle to data pointer */ ProfileData = SpProfileLock (Profile); if (NULL == ProfileData) return SpStatBadProfile; /* Free current FileName if one is there */ if (ProfileData->FileName != NULL) freeBuffer(ProfileData->FileName); /* create the FileName handle */ ProfileData->FileName = allocBufferHandle (strlen (FileName) + 1); if (ProfileData->FileName == NULL) return (SpStatMemory); /* lock FileName handle and return ptr */ fileName = (char *) lockBuffer (ProfileData->FileName); if (fileName == NULL) return (SpStatMemory); /* copy text data into the newly allocated space */ strcpy (fileName, FileName); #if defined (KPMAC) SpProfileClearProps(&(ProfileData->Props)); #endif /* unlock handles */ unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatSuccess; }
void GL3PlusHardwarePixelBuffer::blitFromMemory(const PixelBox &src, const Box &dstBox) { if (!mBuffer.contains(dstBox)) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Destination box out of range", "GL3PlusHardwarePixelBuffer::blitFromMemory"); } PixelBox scaled; if (src.getWidth() != dstBox.getWidth() || src.getHeight() != dstBox.getHeight() || src.getDepth() != dstBox.getDepth()) { // Scale to destination size. // This also does pixel format conversion if needed. allocateBuffer(); scaled = mBuffer.getSubVolume(dstBox); Image::scale(src, scaled, Image::FILTER_BILINEAR); } else if (GL3PlusPixelUtil::getGLInternalFormat(src.format) == 0) { // Extents match, but format is not accepted as valid // source format for GL. Do conversion in temporary buffer. allocateBuffer(); scaled = mBuffer.getSubVolume(dstBox); PixelUtil::bulkPixelConversion(src, scaled); } else { // No scaling or conversion needed. scaled = src; } upload(scaled, dstBox); freeBuffer(); }
/* * Compute 2D DFT on double data: * forward if direction==FFT_FORWARD, * inverse if direction==FFT_INVERSE. */ int fft2d(DCOMPLEX *array, int rows, int cols, int direction) { int i, maxsize, errflag; if(!power_of_2(rows) || !power_of_2(cols)) { handle_error("fft: input array must have dimensions a power of 2"); return(ERROR); } /* Allocate 1D buffer */ bigBuffd = array; maxsize = rows>cols ? rows : cols; errflag = allocateBuffer(maxsize); if(errflag != NO_ERROR) return(errflag); /* Compute transform row by row */ if(cols>1) for(i=0;i<rows;i++) { LoadRow(bigBuffd,i,cols); FFT842(direction,cols,stageBuff); StoreRow(bigBuffd,i,cols); } /* Compute transform column by column */ if(rows>1) for(i=0;i<cols;i++) { LoadCol(bigBuffd,i,rows,cols); FFT842(direction,rows,stageBuff); StoreCol(bigBuffd,i,rows,cols); } freeBuffer(); return(NO_ERROR); }
void TGroup::setState(ushort aState, Boolean enable) { setBlock sb; sb.st = aState; sb.en = enable; TView::setState(aState, enable); if ((aState & (sfActive | sfDragging)) != 0) { lock(); forEach(doSetState, &sb); unlock(); } if ((aState & sfFocused) != 0) { if (current != 0) current->setState(sfFocused, enable); } if ((aState & sfExposed) != 0) { forEach(doExpose, &enable); if (enable == False) freeBuffer(); } }
/* * Processes received authentication tokens as well as supplies the * response token. */ int ne_sspi_authenticate(void *context, const char *base64Token, char **responseToken) { SecBufferDesc outBufferDesc; SecBuffer outBuffer; int status; SECURITY_STATUS securityStatus; ULONG contextFlags; SSPIContext *sspiContext; if (initialized <= 0) { return -1; } status = getContext(context, &sspiContext); if (status) { return status; } /* TODO: Not sure what flags should be set. joe: this needs to be * driven by the ne_auth interface; the GSSAPI code needs similar * flags. */ contextFlags = ISC_REQ_CONFIDENTIALITY | ISC_REQ_MUTUAL_AUTH; initSingleEmptyBuffer(&outBufferDesc, &outBuffer); status = makeBuffer(&outBufferDesc, sspiContext->maxTokenSize); if (status) { return status; } if (base64Token) { SecBufferDesc inBufferDesc; SecBuffer inBuffer; if (!sspiContext->continueNeeded) { freeBuffer(&outBufferDesc); NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: Got an unexpected token.\n"); return -1; } initSingleEmptyBuffer(&inBufferDesc, &inBuffer); status = base64ToBuffer(base64Token, &inBufferDesc); if (status) { freeBuffer(&outBufferDesc); return status; } securityStatus = initializeSecurityContext(&sspiContext->credentials, &(sspiContext->context), sspiContext->serverName, contextFlags, &inBufferDesc, &(sspiContext->context), &outBufferDesc); if (securityStatus == SEC_E_OK) { sspiContext->authfinished = 1; } freeBuffer(&inBufferDesc); } else { if (sspiContext->continueNeeded) { freeBuffer(&outBufferDesc); NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: Expected a token from server.\n"); return -1; } if (sspiContext->authfinished && (sspiContext->credentials.dwLower || sspiContext->credentials.dwUpper)) { if (sspiContext->authfinished) { freeBuffer(&outBufferDesc); sspiContext->authfinished = 0; NE_DEBUG(NE_DBG_HTTPAUTH,"sspi: failing because starting over from failed try.\n"); return -1; } sspiContext->authfinished = 0; } /* Reset any existing context since we are starting over */ resetContext(sspiContext); if (acquireCredentialsHandle (&sspiContext->credentials, sspiContext->mechanism) != SEC_E_OK) { freeBuffer(&outBufferDesc); NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: acquireCredentialsHandle failed.\n"); return -1; } securityStatus = initializeSecurityContext(&sspiContext->credentials, NULL, sspiContext->serverName, contextFlags, NULL, &(sspiContext->context), &outBufferDesc); } if (securityStatus == SEC_I_COMPLETE_AND_CONTINUE || securityStatus == SEC_I_COMPLETE_NEEDED) { SECURITY_STATUS compleStatus = pSFT->CompleteAuthToken(&(sspiContext->context), &outBufferDesc); if (compleStatus != SEC_E_OK) { freeBuffer(&outBufferDesc); NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: CompleteAuthToken failed.\n"); return -1; } } if (securityStatus == SEC_I_COMPLETE_AND_CONTINUE || securityStatus == SEC_I_CONTINUE_NEEDED) { sspiContext->continueNeeded = 1; } else { sspiContext->continueNeeded = 0; } if (!(securityStatus == SEC_I_COMPLETE_AND_CONTINUE || securityStatus == SEC_I_COMPLETE_NEEDED || securityStatus == SEC_I_CONTINUE_NEEDED || securityStatus == SEC_E_OK)) { NE_DEBUG(NE_DBG_HTTPAUTH, "sspi: initializeSecurityContext [failed] [%x].\n", securityStatus); freeBuffer(&outBufferDesc); return -1; } *responseToken = ne_base64(outBufferDesc.pBuffers->pvBuffer, outBufferDesc.pBuffers->cbBuffer); freeBuffer(&outBufferDesc); return 0; }
void freeSysBuffer (KpHandle_t handle) { freeBuffer (handle); }
/*--------------------MemoryManager Class STARTS here-----------------------------*/ void* MemoryManager::allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs) { LOG_FUNCTION_NAME; if (mIonFd == 0) { mIonFd = ion_open(); if (mIonFd == 0) { LOGE("ion_open failed!!!"); return NULL; } } ///We allocate numBufs+1 because the last entry will be marked NULL to indicate end of array, which is used when freeing ///the buffers const uint numArrayEntriesC = (uint)(numBufs + 1); ///Allocate a buffer array uint32_t *bufsArr = new uint32_t[numArrayEntriesC]; if (!bufsArr) { LOGE( "Allocation failed when creating buffers array of %d uint32_t elements", numArrayEntriesC); LOG_FUNCTION_NAME_EXIT; return NULL; } ///Initialize the array with zeros - this will help us while freeing the array in case of error ///If a value of an array element is NULL, it means we didnt allocate it memset(bufsArr, 0, sizeof(*bufsArr) * numArrayEntriesC); //2D Allocations are not supported currently if (bytes != 0) { struct ion_handle *handle; int mmap_fd; ///1D buffers for (int i = 0; i < numBufs; i++) { int ret = ion_alloc(mIonFd, bytes, 0, 1 << ION_HEAP_TYPE_CARVEOUT, &handle); if (ret < 0) { LOGE("ion_alloc resulted in error %d", ret); goto error; } LOGE("Before mapping, handle = %x, nSize = %d", handle, bytes); if ((ret = ion_map(mIonFd, handle, bytes, PROT_READ | PROT_WRITE, MAP_SHARED, 0, (unsigned char**) &bufsArr[i], &mmap_fd)) < 0) { LOGE("Userspace mapping of ION buffers returned error %d", ret); ion_free(mIonFd, handle); goto error; } mIonHandleMap.add(bufsArr[i], (unsigned int) handle); mIonFdMap.add(bufsArr[i], (unsigned int) mmap_fd); mIonBufLength.add(bufsArr[i], (unsigned int) bytes); } } else // If bytes is not zero, then it is a 2-D tiler buffer request { } LOG_FUNCTION_NAME_EXIT; return (void*) bufsArr; error: LOGE("Freeing buffers already allocated after error occurred"); freeBuffer(bufsArr); if (NULL != mErrorNotifier.get()) { mErrorNotifier->errorNotify(-ENOMEM); } LOG_FUNCTION_NAME_EXIT; return NULL; }
BOOL trans_upload_file(iclock_options_t *opt,data_list_t*CurrentNode,int mode) { char url[1024]; char buf[1024]; char str_temp[512]; int c = -1; int file_index; trans_info_t info; int fd; char file_name[128]; int file_offset; int read_data_len = 0; int trans_help_fp; BOOL ret = TRUE; if (CurrentNode == NULL || opt == NULL) { return TRUE; } chmod(BS_TRANS_HELP_FILE,0666); trans_help_fp = open(BS_TRANS_HELP_FILE,O_RDWR|O_NONBLOCK); file_offset = get_file_info(CurrentNode->con_type,mode,file_name); if (trans_help_fp < 0) { return TRUE; } if (file_offset < 0) { close(trans_help_fp); return TRUE; } if ((!read_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(file_index))) || (file_index < 0)) { close(trans_help_fp); return TRUE; } memset(&info,0,sizeof(info)); sprintf(str_temp,"gTransFlag=%s",opt->svr_trans_flag); info.cache = createRamBuffer(opt->buf_size); info.opt = opt; info.list = CurrentNode; read_file_with_offset(trans_help_fp, file_offset+sizeof(file_index),\ (char *)&info.cur_trans_log_time,sizeof(info.cur_trans_log_time)); info.starting_time = (size_t)OldEncodeTime(localtime(&info.cur_trans_log_time)); opt->con_type = CurrentNode->con_type; url_init(opt,url,"OPERLOG"); info.url = url; info.upload_mode = UPLOADE_MODE_QUERY; CurrentNode->param = str_temp; fd = open(file_name,O_RDWR|O_NONBLOCK); if ((fd >= 0) && (file_index >= 0) && (opt->main_fun->upload_usr_read_fun != NULL)) { if (svr_is_need_contype(opt->svr_trans_flag,CurrentNode->con_type)) { while ((read_data_len = opt->main_fun->upload_usr_read_fun(\ CurrentNode->con_type,buf,file_index,fd)) > 0) { c = trans_user_all_data(buf,&info,str_temp,FCT_USER); if ( info.error != 0 || (c < 0)) { break; } c = trans_user_all_data(buf,&info,str_temp,FCT_USERPIC); if ( info.error != 0 || (c < 0)) { break; } c = trans_user_all_data(buf,&info,str_temp,FCT_FACE); if ( info.error != 0 || (c < 0)) { break; } c = trans_user_all_data(buf,&info,str_temp,FCT_FINGERTMP); if ( info.error != 0 || (c < 0)) { break; } if (( info.error == 0) && (info.count == 0) && (c > 0)) { write_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(int)); } file_index += read_data_len; } if (( info.error == 0) && (info.count > 0) && (c >= 0)) { snprintf(info.url+strlen(info.url),sizeof(url)-strlen(info.url), "%u",(unsigned int)info.starting_time); if (cache_data_to_svr(url, &info)) { write_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(int)); } } } if (read_data_len < 1) { file_index = -1; write_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(int)); if (fd > 0) { close(fd); } fd = open(file_name, O_RDWR|O_CREAT|O_TRUNC|O_SYNC); } ret = (read_data_len < 1); } else { ret = TRUE; } freeBuffer(info.cache); if (fd >= 0) { close(fd); } if (trans_help_fp >= 0) { close(trans_help_fp); } return ret; }
/*-------------------- readFile --------------------*/ File_t readFile ( ParameterSpecification_t fileSpecifier, /* in */ const char * filename /* in */ ) { File_t returnValue; FILE * filePointer; long fileLength; if( FileOpened == openFileForReading( filename, &filePointer ) ) { if( Success == getFileLength( filePointer, &fileLength ) ) { void * ptr; /* * Allocate one byte more if a newline must be added */ if( Success == allocateBuffer( fileLength + 1 , &ptr ) ) { char * buffer = ( char * )ptr; if( Success == readFileToBuffer( filePointer, fileLength, &buffer ) ) { if ( FALSE == queryParameter( IgnoreEOF ) ) { char * eof = (buffer + fileLength - 1); if ( *eof != '\n' ) { *( eof + 1 ) = '\n'; fileLength++; } } addToWatchdog( fileLength ); associateBuffer( fileSpecifier, fileLength, &buffer ); returnValue = FileOperationsSuccessful; } else { freeBuffer( &buffer ); returnValue = FileOperationsFailed; } } else { returnValue = FileOperationsFailed; } } else { returnValue = FileOperationsFailed; } closeFile( filePointer ); } else { returnValue = FileOperationsFailed; } return( returnValue ); }
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 }
~free_on_scope_exit() { if(!my_p) return; my_p->~T(); freeBuffer(my_p); }
void run_lambdas_test( mode_array *filter_type ) { tbb::atomic<int> counter; counter = max_counter; // Construct filters using lambda-syntax and create the sequence when parallel_pipeline() is being run; resetCounters(); // only need the output_counter reset. tbb::parallel_pipeline( n_tokens, tbb::make_filter<void, t1>(filter_type[0], [&counter]( tbb::flow_control& control ) -> t1 { if( --counter < 0 ) control.stop(); return t1(); } ) & tbb::make_filter<t1, t2>(filter_type[1], []( t1 /*my_storage*/ ) -> t2 { return t2(); } ) & tbb::make_filter<t2, void>(filter_type[2], [] ( t2 ) -> void { output_counter++; } ) ); checkCounters(no_pointer_counts); // don't have to worry about specializations counter = max_counter; // pointer filters resetCounters(); tbb::parallel_pipeline( n_tokens, tbb::make_filter<void, t1*>(filter_type[0], [&counter]( tbb::flow_control& control ) -> t1* { if( --counter < 0 ) { control.stop(); return NULL; } return new(fetchNextBuffer()) t1(); } ) & tbb::make_filter<t1*, t2*>(filter_type[1], []( t1* my_storage ) -> t2* { tbb::tbb_allocator<t1>().destroy(my_storage); // my_storage->~t1(); return new(my_storage) t2(); } ) & tbb::make_filter<t2*, void>(filter_type[2], [] ( t2* my_storage ) -> void { tbb::tbb_allocator<t2>().destroy(my_storage); // my_storage->~t2(); freeBuffer(my_storage); output_counter++; } ) ); checkCounters(no_pointer_counts); // first filter outputs pointer counter = max_counter; resetCounters(); tbb::parallel_pipeline( n_tokens, tbb::make_filter<void, t1*>(filter_type[0], [&counter]( tbb::flow_control& control ) -> t1* { if( --counter < 0 ) { control.stop(); return NULL; } return new(fetchNextBuffer()) t1(); } ) & tbb::make_filter<t1*, t2>(filter_type[1], []( t1* my_storage ) -> t2 { tbb::tbb_allocator<t1>().destroy(my_storage); // my_storage->~t1(); freeBuffer(my_storage); return t2(); } ) & tbb::make_filter<t2, void>(filter_type[2], [] ( t2 /*my_storage*/) -> void { output_counter++; } ) ); checkCounters(no_pointer_counts); // second filter outputs pointer counter = max_counter; resetCounters(); tbb::parallel_pipeline( n_tokens, tbb::make_filter<void, t1>(filter_type[0], [&counter]( tbb::flow_control& control ) -> t1 { if( --counter < 0 ) { control.stop(); } return t1(); } ) & tbb::make_filter<t1, t2*>(filter_type[1], []( t1 /*my_storage*/ ) -> t2* { return new(fetchNextBuffer()) t2(); } ) & tbb::make_filter<t2*, void>(filter_type[2], [] ( t2* my_storage) -> void { tbb::tbb_allocator<t2>().destroy(my_storage); // my_storage->~t2(); freeBuffer(my_storage); output_counter++; } ) ); checkCounters(no_pointer_counts); }
int main (int argc, char ** argv) { struct timeval start,stop; if(gettimeofday(&start,NULL) == -1) { perror("clock gettime\n"); } pthread_mutex_init(&lockGlobal,NULL); pthread_mutex_init(&lock,NULL); pthread_mutex_lock(&lockGlobal); size = (int*) malloc(sizeof size); *size = 16; global = (struct facteurPremier**)malloc(sizeof(*global)); *global = (struct facteurPremier*) malloc(sizeof(**global) * (*size)); int i; for(i=0;i<*size;i++) { (*global)[i].nombre=0; (*global)[i].multiplicite=0; (*global)[i].file='\0'; } pthread_mutex_unlock(&lockGlobal); pthread_mutex_lock(&lock); isProducing=0; pthread_mutex_unlock(&lock); long maxthreads=1; int threadNum=0; int numofThread=0; pthread_t* prodcuteur= (pthread_t*) malloc(sizeof(*prodcuteur)*argc);// talbeau de thread producteur pthread_t* consommateur=(pthread_t*) malloc(sizeof(*consommateur)*maxthreads); char* argerror; char* internet="http://"; struct buffer* buffer1 = newBuffer(128); if(argc>1) { isProducing=1; for (i = 1; i < argc; i++) { if(!strcmp(argv[i],"-stdin")) { struct producteur_param* param=(struct producteur_param*)malloc(sizeof(*param)); if(param==NULL) { printf("erreur, pas assez de place\n"); } else { param->inputName="stdin"; param->buffer1=buffer1; param->fd_read=0; param->fd_write=1; pthread_create(&prodcuteur[threadNum],NULL,produceFromFD,param); numofThread++; threadNum++; } } else if(!strcmp(argv[i],"-maxthreads")) { i++; if(i>=argc) { printf("erreur, pas assez d'argument\n"); } else { maxthreads = strtol(argv[i], &argerror, 10); // converti en long if (*argerror != '\0') // si erreur dans la conversion { printf("erreur, argument invalide\n"); i--; maxthreads = 1; } else { pthread_t* temp = realloc(consommateur,sizeof(*consommateur)*maxthreads); if(temp==NULL) { printf("erreur de realloc de consommateur\n"); } else { consommateur=temp; } } } } else if(strstr(argv[i],internet)!=NULL) { int fd[2]; pipe(fd); struct producteur_param* param1=(struct producteur_param*)malloc(sizeof(*param1)); struct producteur_param* param2=(struct producteur_param*)malloc(sizeof(*param2)); if(param1==NULL) { printf("erreur pas assez de mémoire\n"); } else { param1->buffer1=buffer1; param1->inputName=argv[i]; param1->fd_read=fd[0]; param1->fd_write=fd[1]; param2->buffer1=buffer1; param2->inputName=argv[i]; param2->fd_read=fd[0]; param2->fd_write=fd[1]; pthread_create(&prodcuteur[threadNum],NULL,produceFromInternet,param1); numofThread++; threadNum++; pthread_create(&prodcuteur[threadNum],NULL,produceFromFD,param2); threadNum++; numofThread++; } } else { //lecture depuis le fichier int fd=open(argv[i],O_RDONLY); if(fd==-1) { printf("erreur de d'ouverture du ficher : %s\n",argv[i]); } else { struct producteur_param* param = (struct producteur_param*)malloc(sizeof(*param)); if(param==NULL) { printf("erreur pas assez de mémoire\n"); } else { param->buffer1=buffer1; param->inputName=argv[i]; param->fd_read=fd; param->fd_write=1; pthread_create(&prodcuteur[threadNum],NULL,produceFromFD,param); numofThread++; threadNum++; } } } } int j; for(j = 0; j<maxthreads;j++) { struct consommateur_param* param = (struct consommateur_param*)malloc(sizeof(*param)); param->lock=&lock; param->buffer1=buffer1; param->isProducing=&isProducing; param->num=j; param->global=global; param->lockGlobal=&lockGlobal; param->size = size; pthread_create(&consommateur[j],NULL,consumme,param); } int cursor; for(cursor=0;cursor<numofThread;cursor++) { pthread_join(prodcuteur[cursor],NULL); } pthread_mutex_lock(&lock); isProducing=0; pthread_mutex_unlock(&lock); for(cursor=0;cursor<maxthreads;cursor++) { pthread_join(consommateur[cursor],NULL); } int succes = searchUniquePrime(*global,size); if(gettimeofday(&stop,NULL) == -1) { perror("clock gettime\n"); } long int sec = stop.tv_sec-start.tv_sec; long long int usec = (1000000-start.tv_usec+stop.tv_usec); printf("%ld.%lld s\n",sec,usec/1000); freeBuffer(buffer1); free(consommateur); free(size); free(*global); free(global); free(prodcuteur); consommateur=NULL; size=NULL; *global=NULL; global=NULL; prodcuteur=NULL; pthread_mutex_destroy(&lockGlobal); pthread_mutex_destroy(&lock); return succes; } return EXIT_FAILURE; }
void FastaFile::allocateBuffer(int bufLength) { freeBuffer(); pcLine = new char[bufLength]; nMaxLineLength = bufLength; }
BOOL Matrix::setData (size_t len, size_t dimen, REAL **buf) { freeBuffer(); return appendData(len, dimen, buf); }
TerrainGridRenderable::~TerrainGridRenderable() { freeBuffer(); }
void deallocateDataBuffer(DataBuffer buffer) { if (buffer->count > 0) freeBuffer(buffer, buffer->minSeqNo, buffer->minSeqNo + buffer->count - 1); free(buffer->data); free(buffer); }
void sodero_destroy_session_manager(PSoderoSessionManager object) { if (object) { sodero_finalize_session_manager(object); freeBuffer(object); } }
CjfConvert::~CjfConvert() { freeBuffer(); }
status_t BnOMX::onTransact( uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) { switch (code) { case LIVES_LOCALLY: { CHECK_INTERFACE(IOMX, data, reply); reply->writeInt32(livesLocally((pid_t)data.readInt32())); return OK; } case LIST_NODES: { CHECK_INTERFACE(IOMX, data, reply); List<ComponentInfo> list; listNodes(&list); reply->writeInt32(list.size()); for (List<ComponentInfo>::iterator it = list.begin(); it != list.end(); ++it) { ComponentInfo &cur = *it; reply->writeString8(cur.mName); reply->writeInt32(cur.mRoles.size()); for (List<String8>::iterator role_it = cur.mRoles.begin(); role_it != cur.mRoles.end(); ++role_it) { reply->writeString8(*role_it); } } return NO_ERROR; } case ALLOCATE_NODE: { CHECK_INTERFACE(IOMX, data, reply); const char *name = data.readCString(); sp<IOMXObserver> observer = interface_cast<IOMXObserver>(data.readStrongBinder()); node_id node; status_t err = allocateNode(name, observer, &node); reply->writeInt32(err); if (err == OK) { reply->writeIntPtr((intptr_t)node); } return NO_ERROR; } case FREE_NODE: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); reply->writeInt32(freeNode(node)); return NO_ERROR; } case SEND_COMMAND: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_COMMANDTYPE cmd = static_cast<OMX_COMMANDTYPE>(data.readInt32()); OMX_S32 param = data.readInt32(); reply->writeInt32(sendCommand(node, cmd, param)); return NO_ERROR; } case GET_PARAMETER: case SET_PARAMETER: case GET_CONFIG: case SET_CONFIG: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_INDEXTYPE index = static_cast<OMX_INDEXTYPE>(data.readInt32()); size_t size = data.readInt32(); void *params = malloc(size); data.read(params, size); status_t err; switch (code) { case GET_PARAMETER: err = getParameter(node, index, params, size); break; case SET_PARAMETER: err = setParameter(node, index, params, size); break; case GET_CONFIG: err = getConfig(node, index, params, size); break; case SET_CONFIG: err = setConfig(node, index, params, size); break; default: TRESPASS(); } reply->writeInt32(err); if ((code == GET_PARAMETER || code == GET_CONFIG) && err == OK) { reply->write(params, size); } free(params); params = NULL; return NO_ERROR; } case GET_STATE: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_STATETYPE state = OMX_StateInvalid; status_t err = getState(node, &state); reply->writeInt32(state); reply->writeInt32(err); return NO_ERROR; } case ENABLE_GRAPHIC_BUFFERS: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); OMX_BOOL enable = (OMX_BOOL)data.readInt32(); status_t err = enableGraphicBuffers(node, port_index, enable); reply->writeInt32(err); return NO_ERROR; } case GET_GRAPHIC_BUFFER_USAGE: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); OMX_U32 usage = 0; status_t err = getGraphicBufferUsage(node, port_index, &usage); reply->writeInt32(err); reply->writeInt32(usage); return NO_ERROR; } case USE_BUFFER: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); sp<IMemory> params = interface_cast<IMemory>(data.readStrongBinder()); buffer_id buffer; status_t err = useBuffer(node, port_index, params, &buffer); reply->writeInt32(err); if (err == OK) { reply->writeIntPtr((intptr_t)buffer); } return NO_ERROR; } case USE_GRAPHIC_BUFFER: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); sp<GraphicBuffer> graphicBuffer = new GraphicBuffer(); data.read(*graphicBuffer); buffer_id buffer; status_t err = useGraphicBuffer( node, port_index, graphicBuffer, &buffer); reply->writeInt32(err); if (err == OK) { reply->writeIntPtr((intptr_t)buffer); } return NO_ERROR; } case STORE_META_DATA_IN_BUFFERS: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); OMX_BOOL enable = (OMX_BOOL)data.readInt32(); status_t err = storeMetaDataInBuffers(node, port_index, enable); reply->writeInt32(err); return NO_ERROR; } case ALLOC_BUFFER: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); size_t size = data.readInt32(); buffer_id buffer; void *buffer_data; status_t err = allocateBuffer( node, port_index, size, &buffer, &buffer_data); reply->writeInt32(err); if (err == OK) { reply->writeIntPtr((intptr_t)buffer); reply->writeIntPtr((intptr_t)buffer_data); } return NO_ERROR; } case ALLOC_BUFFER_WITH_BACKUP: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); sp<IMemory> params = interface_cast<IMemory>(data.readStrongBinder()); buffer_id buffer; status_t err = allocateBufferWithBackup( node, port_index, params, &buffer); reply->writeInt32(err); if (err == OK) { reply->writeIntPtr((intptr_t)buffer); } return NO_ERROR; } case FREE_BUFFER: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); OMX_U32 port_index = data.readInt32(); buffer_id buffer = (void*)data.readIntPtr(); reply->writeInt32(freeBuffer(node, port_index, buffer)); return NO_ERROR; } case FILL_BUFFER: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); buffer_id buffer = (void*)data.readIntPtr(); reply->writeInt32(fillBuffer(node, buffer)); return NO_ERROR; } case EMPTY_BUFFER: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); buffer_id buffer = (void*)data.readIntPtr(); OMX_U32 range_offset = data.readInt32(); OMX_U32 range_length = data.readInt32(); OMX_U32 flags = data.readInt32(); OMX_TICKS timestamp = data.readInt64(); reply->writeInt32( emptyBuffer( node, buffer, range_offset, range_length, flags, timestamp)); return NO_ERROR; } case GET_EXTENSION_INDEX: { CHECK_INTERFACE(IOMX, data, reply); node_id node = (void*)data.readIntPtr(); const char *parameter_name = data.readCString(); OMX_INDEXTYPE index; status_t err = getExtensionIndex(node, parameter_name, &index); reply->writeInt32(err); if (err == OK) { reply->writeInt32(index); } return OK; } default: return BBinder::onTransact(code, data, reply, flags); } }
DynImage::Contents::~Contents() { if (freeBuffer) { fprintf(stderr, "freeBuffer %p\n", &buf); freeBuffer(&buf); } }
void freeBufferPtr (KpGenericPtr_t p) { freeBuffer ((KpGenericPtr_t) p); }
CbrPage::CbrPage(const CbrPage &page) : name(page.name), totalSize(page.totalSize), curSize(page.curSize), buffer(NULL) { freeBuffer(); buffer = new char[page.curSize]; memcpy(buffer, page.buffer, page.curSize); }
void freeSysBufferPtr (KpGenericPtr_t p) { freeBuffer ((KpHandle_t) p); }
CbrPage::~CbrPage() { freeBuffer(); }
ImageBuffer::~ImageBuffer() { if (m_buffer) { freeBuffer(); } }
void CglAxis::display(){ int shaderID = initProgram(pcv->fresnelID()); GLuint MatrixID = glGetUniformLocation(shaderID, "MVP"); GLuint colorID = glGetUniformLocation(shaderID, "COL"); GLuint MID = glGetUniformLocation(shaderID, "M"); GLuint VID = glGetUniformLocation(shaderID, "V"); int fill_light_ID = glGetUniformLocation(shaderID, "FILL"); int side_light_ID = glGetUniformLocation(shaderID, "SIDE"); int back_light_ID = glGetUniformLocation(shaderID, "BACK"); int gridID = glGetUniformLocation(shaderID, "GRID"); //GRID if( (pcv->profile.displayBottomGrid) && (pScene->scene_type != CGL_GALERY) ){ enableFog(shaderID); glm::mat4 VIEW = sVIEW(); glm::mat4 MVP = sPROJ() * sVIEW() * sMODEL() * glm::translate( glm::scale(glm::mat4(1), glm::vec3(pScene->getScale(),1,pScene->getScale())), glm::vec3(0) );//glm::vec3(sMODEL()[3]) ); //glm::translate(glm::mat4(1), center) * // glm::scale(glm::translate( sPROJ() * VIEW * MODEL, center), // glm::vec3(pScene->getScale(), 1, pScene->getScale())) * // glm::translate(glm::mat4(1), -center); uniform(MatrixID, MVP); uniform(MID, MODEL); uniform(VID, VIEW); uniform(colorID, glm::vec3(0.,0.,1.0)); std::vector<pCglLight> lights = pcv->getSubWindow()->getScene()->getLights(); uniform( fill_light_ID, *(lights[0]->getLightMatrix(pMaterial))); uniform( side_light_ID, *(lights[1]->getLightMatrix(pMaterial))); uniform( back_light_ID, *(lights[2]->getLightMatrix(pMaterial))); uniform(gridID, 1.0f); //glLineWidth(1.0); //bindBuffer(0, GL_ARRAY_BUFFER, secondaryGridBuffer); //glBindAttribLocation( shaderID, 0, "vertex_position"); //glDrawArrays(GL_LINES, 0, secondaryGrid.size()/3); glEnable(GL_BLEND); //glLineWidth(2.0); bindBuffer(0, GL_ARRAY_BUFFER, mainGridBuffer); glBindAttribLocation( shaderID, 0, "vertex_position"); bindBuffer(1, GL_ARRAY_BUFFER, nBuffer); glBindAttribLocation( shaderID, 1, "vertex_normal"); //glDrawArrays(GL_QUADS, 0, mainGrid.size()/3); //STENCIL WRITING glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 1, 0xFF); // Set any stencil to 1 glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilMask(0xFF); // Write to stencil buffer glDepthMask(GL_FALSE); // Don't write to depth buffer glClear(GL_STENCIL_BUFFER_BIT); glDrawArrays(GL_QUADS, 0, mainGrid.size()/3); glStencilFunc(GL_EQUAL, 1, 0xFF); // Pass test if stencil value is 1 glStencilMask(0x00); // Don't write anything to stencil buffer glDepthMask(GL_TRUE); // Write to depth buffer glDisable(GL_STENCIL_TEST); //Draw d'un contour //glLineWidth(10.0f); //uniform(gridID, 0.0f); //glEnable(GL_POLYGON_OFFSET_LINE); //glPolygonOffset(1.0,1.0); //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); //glDrawArrays(GL_QUADS, 0, mainGrid.size()/3); //glDisable(GL_POLYGON_OFFSET_LINE); //glLineWidth(1.0f); glDisable(GL_BLEND); disableFog(shaderID); glPolygonMode(GL_FRONT, GL_FILL); } shaderID = initProgram(pcv->simpleID()); glPolygonMode(GL_FRONT, GL_LINE); MatrixID = glGetUniformLocation(shaderID, "MVP"); colorID = glGetUniformLocation(shaderID, "COL"); MID = glGetUniformLocation(shaderID, "M"); VID = glGetUniformLocation(shaderID, "V"); //Axes if(pcv->profile.displayAxes){ glDisable(GL_DEPTH_TEST); glViewport(0,0,view->width/6,view->width/6); glm::mat4 NEUTRAL = glm::mat4(glm::perspective(70.0, 1.0, view->m_znear, view->m_zfar)) * sVIEW() * glm::mat4(1); glm::mat4 M = glm::scale(NEUTRAL, glm::vec3(view->zoom)); uniform(MatrixID, M); bindBuffer(0, GL_ARRAY_BUFFER, axesBuffer); glBindAttribLocation( shaderID, 0, "vertex_position"); glLineWidth(2.0); uniform(colorID, glm::vec3(1,0,0)); glDrawArrays(GL_LINES, 0, 2); uniform(colorID, glm::vec3(0,1,0)); glDrawArrays(GL_LINES, 2, 4); uniform(colorID, glm::vec3(0,0,1)); glDrawArrays(GL_LINES, 4, 6); view->reshape(view->width,view->height); glEnable(GL_DEPTH_TEST); } glLineWidth(1.0); glPolygonMode(GL_FRONT, GL_FILL); freeBuffer(); }
void * backend_thread(){ // connection for listening on a port // 2 conn_t cannot be allocated on stack (see comment on conn_t) // since cause a seg faults conn_t * pConnListen; conn_t * pConn; pid_t childpid, childpid2; int status; //int retval = 0; // Network state // FIXME cuda_bridge_request_t == cuda_packet_t == rpkt_t, this is rediculous strm_hdr_t *hdr = NULL; rpkt_t *rpkts = NULL; // array of cuda packets if( (pConnListen = conn_malloc(__FUNCTION__, NULL)) == NULL ) return NULL; // this allocates memory for the strm.rpkts, i.e., the array of packets if( (pConn = conn_malloc(__FUNCTION__, NULL)) == NULL ) return NULL; fprintf(stderr, "**************************************\n"); fprintf(stderr, "%s.%d: hey, here server thread!\n", __FUNCTION__, __LINE__); fprintf(stderr, "**************************************\n"); // set up the connection conn_localbind(pConnListen); for(;;) { conn_accept(pConnListen, pConn); // blocking printf("ACCEPTED A CONN***********\n"); if((childpid = fork()) == 0) { if((childpid2 = fork()) == 0) { // CLOSE the listen connection // conn_close(pConnListen); // Connection-related structures hdr = &pConn->strm.hdr; rpkts = pConn->strm.rpkts; // an array of packets (MAX_REMOTE_BATCH_SIZE) // these are buffers for extra data transferred as pConn->pReqBuffer = NULL; pConn->pRspBuffer = NULL; while(1) { p_debug("------------------New RPC--------------------\n"); memset(hdr, 0, sizeof(strm_hdr_t)); memset(rpkts, 0, MAX_REMOTE_BATCH_SIZE * sizeof(rpkt_t)); pConn->request_data_size = 0; pConn->response_data_size = 0; pConn->pReqBuffer = freeBuffer(pConn->pReqBuffer); pConn->pRspBuffer = freeBuffer(pConn->pRspBuffer); //recv the header describing the batch of remote requests if (1 != get(pConn, hdr, sizeof(strm_hdr_t))) { break; } p_debug(" received request header. Expecting %d packets. And extra request buffer of data size %d\n", hdr->num_cuda_pkts, hdr->data_size); if (hdr->num_cuda_pkts <= 0) { p_warn("Received header specifying zero packets, ignoring\n"); continue; } // Receive the entire batch. // first the packets, then the extra data (reqbuf) // // let's assume that we have enough space. otherwise we have a problem // pConn allocates the buffers for incoming cuda packets // so we should be fine if(1 != get(pConn, rpkts, hdr->num_cuda_pkts * sizeof(rpkt_t))) { break; } p_info("Received %d packets, each of size of (%lu) bytes\n", hdr->num_cuda_pkts, sizeof(rpkt_t)); p_info( "Received method %s (method_id %d) from Thr_id: %lu.\n", methodIdToString(rpkts[0].method_id), rpkts[0].method_id, rpkts[0].thr_id); // receiving the request buffer if any if(hdr->data_size > 0){ p_info("Expecting data size/Buffer: %u, %d.\n", hdr->data_size, pConn->request_data_size); // let's assume that the expected amount of data will fit into // the buffer we have (size of pConn->request_data_buffer // allocate the right amount of memory for the request buffer pConn->pReqBuffer = malloc(hdr->data_size); if( mallocCheck(pConn->pReqBuffer, __FUNCTION__, NULL) == ERROR ){ break; } //assert(hdr->data_size <= TOTAL_XFER_MAX); if(1 != get(pConn, pConn->pReqBuffer, hdr->data_size)){ pConn->pReqBuffer = freeBuffer(pConn->pReqBuffer); break; } pConn->request_data_size = hdr->data_size; p_info( "Received request buffer (%d bytes)\n", pConn->request_data_size); } // execute the request pkt_execute(&rpkts[0], pConn); // we need to send the one response packet + response_buffer if any // @todo you need to check if he method needs to send // and extended response - you need to provide the right // data_size if( strm_expects_response(&pConn->strm) ){ // send the header about response p_debug( "pConn->response_data_size %d\n", pConn->response_data_size); if (conn_sendCudaPktHdr(&*pConn, 1, pConn->response_data_size) == ERROR) { p_info( "__ERROR__ after : Sending the CUDA packet response header: Quitting ... \n"); break; } // send the standard response (with cuda_error_t, and simple arguments etc) if (1 != put(pConn, rpkts, sizeof(rpkt_t))) { p_info("__ERROR__ after : Sending CUDA response packet: Quitting ... \n"); break; } p_info("Response packet sent.\n"); // send the extra data if you have anything to send if( pConn->response_data_size > 0 ){ if (1 != put(pConn, pConn->pRspBuffer, pConn->response_data_size)) { p_info("__ERROR__ after: Sending accompanying response buffer: Quitting ... \n" ); break; } p_info( "Response buffer sent (%d) bytes.\n", pConn->response_data_size); } } } freeBuffer(pConn->pReqBuffer); freeBuffer(pConn->pRspBuffer); conn_close(pConnListen); conn_close(pConn); free(pConnListen); free(pConn); return NULL; } //if(childpid2==0) else exit(0); } //if(childpid==0) //CLOSE THE other conn conn_close(pConn); waitpid(childpid, &status, NULL); }//for(;;) }
Matrix::~Matrix () { freeBuffer(); }