Beispiel #1
0
bool FastArrayInit(FastArray * arr) {
	bool result = false;
	arr->privateFields.freedListHeader.size = 0;
	arr->privateFields.freedListHeader.firstIterator = 1;
	arr->privateFields.freedListHeader.lastIterator = NULL_ITERATOR;

	arr->privateFields.filledListHeader.size = 0;
	arr->privateFields.filledListHeader.firstIterator = NULL_ITERATOR;
	arr->privateFields.filledListHeader.lastIterator = NULL_ITERATOR;

	arr->privateFields.maxArraySize = 0;
	arr->privateFields.iteratorSize = 1;

	fa_element_iterator nextIt = 1;
	fa_element_iterator currentIt = 1;

	while (((arr->privateFields.freedListHeader.size + 1) * ELEMENT_SIZE(arr)) <= arr->bufferSize) {
		currentIt = nextIt;
		nextIt++;
		writeNextIterator(arr, currentIt, nextIt);
		arr->privateFields.freedListHeader.lastIterator = currentIt;
		arr->privateFields.freedListHeader.size++;
		if (nextIt + 1 == NULL_ITERATOR) {
			break;
		}
		if ((nextIt + 1) >= 255) {
			break;
		}
		arr->privateFields.maxArraySize = nextIt - 1;
	}
	fa_element_iterator nullIt = NULL_ITERATOR;
	writeNextIterator(arr, arr->privateFields.freedListHeader.lastIterator, nullIt);
	result = true;
	return result;
}
Beispiel #2
0
Datei: ocl.c Projekt: nasa/QuIP
static void _ocl_offset_data(QSP_ARG_DECL  Data_Obj *dp, index_t offset)
{
#ifndef USE_OPENCL_SUBREGION
	/* The original code used subBuffers, but overlapping subregions
	 * don't work...
	 * So instead we use a common memory buffer, but keep track
	 * of the starting offset (in elements).  This offset has
	 * to be passed to the kernels.
	 */

//fprintf(stderr,"ocl_offset_data:  obj %s, offset = %d\n",OBJ_NAME(dp),offset);
//fprintf(stderr,"\tparent obj %s, parent offset = %d\n",OBJ_NAME(OBJ_PARENT(dp)),
//OBJ_OFFSET(OBJ_PARENT(dp)));

	if( IS_COMPLEX(dp) ){
		assert( (offset & 1) == 0 );
		offset /= 2;
//fprintf(stderr,"Adjusted offset (%d) for complex object %s\n",offset,OBJ_NAME(dp));
	} else if( IS_QUAT(dp) ){
		assert( (offset & 3) == 0 );
		offset /= 4;
	}

	SET_OBJ_DATA_PTR(dp,OBJ_DATA_PTR(OBJ_PARENT(dp)));
	SET_OBJ_OFFSET( dp, OBJ_OFFSET(OBJ_PARENT(dp)) + offset );

#else // USE_OPENCL_SUBREGION
	cl_mem buf;
	cl_mem parent_buf;
	cl_buffer_region reg;
	cl_int status;
	int extra_offset;

	parent_buf = find_parent_buf(OBJ_PARENT(dp),&extra_offset);
	assert( parent_buf != NULL );

	reg.origin = (offset+extra_offset) * ELEMENT_SIZE(dp);

	// No - the region has to be big enough for all of the elements.
	// The safest thing is to include everything from the start
	// of the subregion to the end of the parent.  Note that this
	// cannot handle negative increments!?
	// reg.size = OBJ_N_MACH_ELTS(dp) * ELEMENT_SIZE(dp);

	//   p p p p p p p
	//   p p c c c p p
	//   p p p p p p p
	//   p p c c c p p

	reg.size =	  OBJ_SEQ_INC(dp)*(OBJ_SEQS(dp)-1)
			+ OBJ_FRM_INC(dp)*(OBJ_FRAMES(dp)-1)
			+ OBJ_ROW_INC(dp)*(OBJ_ROWS(dp)-1)
			+ OBJ_PXL_INC(dp)*(OBJ_COLS(dp)-1)
			+ OBJ_COMP_INC(dp)*(OBJ_COMPS(dp)-1)
			+ 1;
	reg.size *= ELEMENT_SIZE(dp);
//fprintf(stderr,"requesting subregion of %ld bytes at offset %ld\n",
//reg.size,reg.origin);

	buf = clCreateSubBuffer ( parent_buf,
				CL_MEM_READ_WRITE,
				CL_BUFFER_CREATE_TYPE_REGION,
		&reg,
			&status);
	if( status != CL_SUCCESS ){
		report_ocl_error(status, "clCreateSubBuffer");
		SET_OBJ_DATA_PTR(dp,OBJ_DATA_PTR(OBJ_PARENT(dp)));
	} else {
		SET_OBJ_DATA_PTR(dp,buf);
	}
	// BUG - Because this object doesn't "own" the data, the sub-buffer
	// won't be released when the object is destroyed, a possible memory
	// leak...
	// We need to add a special case, or make data releasing a
	// platform-specific function...
#endif // USE_OPENCL_SUBREGION
}