UniqueRandomIterator<T>::UniqueRandomIterator (deUint32 numItems, deUint32 numValues, int seed)
{
	de::Random rnd(seed);

	DE_ASSERT(numItems <= numValues);

	if (numItems == numValues)
	{
		// Fast way to populate the index sequence
		m_indices = std::vector<deUint32>(numItems);

		for (deUint32 itemNdx = 0; itemNdx < numItems; itemNdx++)
			m_indices[itemNdx] = itemNdx;
	}
	else
	{
		std::set<deUint32> uniqueIndices;

		// Populate set with "numItems" unique values between 0 and numValues - 1
		while (uniqueIndices.size() < numItems)
			uniqueIndices.insert(rnd.getUint32() % numValues);

		// Copy set into index sequence
		m_indices = std::vector<deUint32>(uniqueIndices.begin(), uniqueIndices.end());
	}

	// Scramble the indices
	rnd.shuffle(m_indices.begin(), m_indices.end());

	reset();
}
void ContainerFormatParser::getData (deUint8* dst, int numBytes, int offset)
{
	DE_ASSERT(de::inBounds(offset, 0, m_elementLen) && numBytes > 0 && de::inRange(numBytes+offset, 0, m_elementLen));

	for (int ndx = 0; ndx < numBytes; ndx++)
		dst[ndx] = m_buf.peekBack(offset+ndx);
}
void RingBuffer<T>::resize (int newSize)
{
	DE_ASSERT(newSize >= m_numElements);
	T* buf = new T[newSize];

	try
	{
		// Copy old elements.
		for (int ndx = 0; ndx < m_numElements; ndx++)
			buf[ndx] = m_buffer[(m_back + ndx) % m_size];

		// Reset pointers.
		m_front		= m_numElements;
		m_back		= 0;
		m_size		= newSize;

		DE_SWAP(T*, buf, m_buffer);
		delete[] buf;
	}
	catch (...)
	{
		delete[] buf;
		throw;
	}
}
Ejemplo n.º 4
0
std::ostream& operator<< (std::ostream& str, const TypeAccessFormat& format)
{
	const VarType* curType = &format.type;

	for (TypeComponentVector::const_iterator iter = format.path.begin(); iter != format.path.end(); iter++)
	{
		switch (iter->type)
		{
			case VarTypeComponent::ARRAY_ELEMENT:
				curType = &curType->getElementType(); // Update current type.
				// Fall-through.

			case VarTypeComponent::MATRIX_COLUMN:
			case VarTypeComponent::VECTOR_COMPONENT:
				str << "[" << iter->index << "]";
				break;

			case VarTypeComponent::STRUCT_MEMBER:
			{
				const StructMember& member = curType->getStructPtr()->getMember(iter->index);
				str << "." << member.getName();
				curType = &member.getType();
				break;
			}

			default:
				DE_ASSERT(false);
		}
	}

	return str;
}
int wrap (Sampler::WrapMode mode, int c, int size)
{
	switch (mode)
	{
		// \note CL and GL modes are handled identically here, as verification process accounts for
		//		 accuracy differences caused by different methods (wrapping vs. denormalizing first).
		case tcu::Sampler::CLAMP_TO_BORDER:
			return deClamp32(c, -1, size);

		case tcu::Sampler::CLAMP_TO_EDGE:
			return deClamp32(c, 0, size-1);

		case tcu::Sampler::REPEAT_GL:
		case tcu::Sampler::REPEAT_CL:
			return imod(c, size);

		case tcu::Sampler::MIRRORED_REPEAT_GL:
		case tcu::Sampler::MIRRORED_REPEAT_CL:
			return (size - 1) - mirror(imod(c, 2*size) - size);

		default:
			DE_ASSERT(DE_FALSE);
			return 0;
	}
}
static void handle_dlm_load_cfm(hic_dlm_load_cfm_t *cfm)
{
   hic_message_context_t msg_ref;
   hic_dlm_load_req_t *req;

   DE_ASSERT(dlm_state.ops);

   if(cfm->remaining_size == 0)
   {
      /* done */
      WiFiEngine_AllowPowerSave(dlm_state.ps_ctrl);
      return;
   }

   create_dlm_req_and_update_state( 
         &msg_ref,
         &req, 
         cfm->address,
         cfm->remaining_size);

   DE_TRACE_INT4(TR_INITIALIZE, "DLM_REQ a:%x s:%u rs:%u c:%x\n",
         req->address,
         req->page.size,
         req->remaining_size,
         req->checksum);

   send_and_free(&msg_ref,req);
}
Ejemplo n.º 7
0
static deBool qpTestLog_writeKeyValuePair (qpTestLog* log, const char* elementName, const char* name, const char* description, const char* unit, qpKeyValueTag tag, const char* text)
{
	const char*		tagString = QP_LOOKUP_STRING(s_qpTagMap, tag);
	qpXmlAttribute	attribs[8];
	int				numAttribs = 0;

	DE_ASSERT(log && elementName && text);
	deMutex_lock(log->lock);

	/* Fill in attributes. */
	if (name)			attribs[numAttribs++] = qpSetStringAttrib("Name", name);
	if (description)	attribs[numAttribs++] = qpSetStringAttrib("Description", description);
	if (tagString)		attribs[numAttribs++] = qpSetStringAttrib("Tag", tagString);
	if (unit)			attribs[numAttribs++] = qpSetStringAttrib("Unit", unit);

	if (!qpXmlWriter_startElement(log->writer, elementName, numAttribs, attribs) ||
		!qpXmlWriter_writeString(log->writer, text) ||
		!qpXmlWriter_endElement(log->writer, elementName))
	{
		qpPrintf("qpTestLog_writeKeyValuePair(): Writing XML failed\n");
		deMutex_unlock(log->lock);
		return DE_FALSE;
	}

	deMutex_unlock(log->lock);
	return DE_TRUE;
}
/** Reads read buffer's depth data (assuming it's of 32-bit FP resolution)
 *  and verifies its correctness.
 *
 *  @param texture_size Texture size
 *  @param n_layer      Index of the layer to verify.
 *
 *  @return true if the retrieved data was found correct, false otherwise.
 **/
bool TextureCubeMapArrayColorDepthAttachmentsTest::verifyDepth32FData(const _texture_size& texture_size,
																	  glw::GLuint		   n_layer)
{
	/* Allocate buffer for the data we will retrieve from the implementation */
	glw::GLfloat		  expected_value   = (glw::GLfloat)n_layer / 256.0f;
	const glw::Functions& gl			   = m_context.getRenderContext().getFunctions();
	bool				  result		   = false;
	const glw::GLuint	 result_data_size = texture_size.m_size * texture_size.m_size;
	glw::GLfloat*		  result_data	  = new glw::GLfloat[result_data_size];

	DE_ASSERT(result_data != NULL);

	/* Read the data */
	gl.readPixels(0, /* x */
				  0, /* y */
				  texture_size.m_size, texture_size.m_size, m_depth_format, m_depth_type, result_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed");

	/* Verify image, expected value is layer index */
	result = verifyImage<glw::GLfloat, 1>(texture_size.m_size, texture_size.m_size, &expected_value, result_data);

	/* Release the buffer */
	if (result_data != NULL)
	{
		delete[] result_data;

		result_data = NULL;
	}

	return result;
}
	explicit Message (MessageType type_)
		: type(type_)
	{
		DE_ASSERT(type_ == MESSAGE_RESUME	||
				  type_ == MESSAGE_PAUSE	||
				  type_ == MESSAGE_FINISH);
	}
Ejemplo n.º 10
0
rr::BlendFunc mapGLBlendFunc (deUint32 func)
{
	switch (func)
	{
		case GL_ZERO:						return rr::BLENDFUNC_ZERO;
		case GL_ONE:						return rr::BLENDFUNC_ONE;
		case GL_SRC_COLOR:					return rr::BLENDFUNC_SRC_COLOR;
		case GL_ONE_MINUS_SRC_COLOR:		return rr::BLENDFUNC_ONE_MINUS_SRC_COLOR;
		case GL_DST_COLOR:					return rr::BLENDFUNC_DST_COLOR;
		case GL_ONE_MINUS_DST_COLOR:		return rr::BLENDFUNC_ONE_MINUS_DST_COLOR;
		case GL_SRC_ALPHA:					return rr::BLENDFUNC_SRC_ALPHA;
		case GL_ONE_MINUS_SRC_ALPHA:		return rr::BLENDFUNC_ONE_MINUS_SRC_ALPHA;
		case GL_DST_ALPHA:					return rr::BLENDFUNC_DST_ALPHA;
		case GL_ONE_MINUS_DST_ALPHA:		return rr::BLENDFUNC_ONE_MINUS_DST_ALPHA;
		case GL_CONSTANT_COLOR:				return rr::BLENDFUNC_CONSTANT_COLOR;
		case GL_ONE_MINUS_CONSTANT_COLOR:	return rr::BLENDFUNC_ONE_MINUS_CONSTANT_COLOR;
		case GL_CONSTANT_ALPHA:				return rr::BLENDFUNC_CONSTANT_ALPHA;
		case GL_ONE_MINUS_CONSTANT_ALPHA:	return rr::BLENDFUNC_ONE_MINUS_CONSTANT_ALPHA;
		case GL_SRC_ALPHA_SATURATE:			return rr::BLENDFUNC_SRC_ALPHA_SATURATE;
		case GL_SRC1_COLOR:					return rr::BLENDFUNC_SRC1_COLOR;
		case GL_ONE_MINUS_SRC1_COLOR:		return rr::BLENDFUNC_ONE_MINUS_SRC1_COLOR;
		case GL_SRC1_ALPHA:					return rr::BLENDFUNC_SRC1_ALPHA;
		case GL_ONE_MINUS_SRC1_ALPHA:		return rr::BLENDFUNC_ONE_MINUS_SRC1_ALPHA;
		default:
			DE_ASSERT(false);
			return rr::BLENDFUNC_LAST;
	}
}
Ejemplo n.º 11
0
int core_dump_append(void *ctx, void *data, size_t len)
{
    struct dump_s *s = (struct dump_s*)ctx;

    if(s==NULL)
    {
       return -1;
    }

    if( s->cache )
	 { 
		 /* Coredump cache must be larger then each packet */
       DE_ASSERT(len < DE_COREDUMP_CACHE_SIZE);
       if(s->cache_off + len >= DE_COREDUMP_CACHE_SIZE)
		 { 
          s->written += de_fwrite(s->file, s->cache, s->cache_off);
          s->cache_off = 0;
       }

       DE_MEMCPY(s->cache + s->cache_off, data, len);
       s->cache_off += len;
    } else { 
       s->written += de_fwrite(s->file, (char*)data, len);
    }

    DE_TRACE_INT2(TR_NOISE, "wrote %d file at %d\n", len, s->written);

    return len;
}
static void stripLeadingPath (char* fileName, const char* pathPrefix)
{
	int pathLen		= strlen(pathPrefix);
	int fileNameLen	= strlen(fileName);

	DE_ASSERT(beginsWithPath(fileName, pathPrefix));

	/* Strip trailing / */
	while (pathLen > 0 && pathPrefix[pathLen-1] == '/')
		pathLen -= 1;

	DE_ASSERT(pathLen > 0);
	DE_ASSERT(fileName[pathLen] == '/');

	memmove(&fileName[0], &fileName[0]+pathLen+1, fileNameLen-pathLen);
}
void deProcess_cleanupHandles (deProcess* process)
{
	DE_ASSERT(!deProcess_isRunning(process));

	if (process->standardErr)
		deFile_destroy(process->standardErr);

	if (process->standardOut)
		deFile_destroy(process->standardOut);

	if (process->standardIn)
		deFile_destroy(process->standardIn);

	if (process->procInfo.hProcess)
		CloseHandle(process->procInfo.hProcess);

	if (process->procInfo.hThread)
		CloseHandle(process->procInfo.hThread);

	process->standardErr		= DE_NULL;
	process->standardOut		= DE_NULL;
	process->standardIn			= DE_NULL;
	process->procInfo.hProcess	= DE_NULL;
	process->procInfo.hThread	= DE_NULL;
}
Ejemplo n.º 14
0
/*--------------------------------------------------------------------*//*!
 * \brief Start thread.
 *
 * Starts thread that will execute the virtual run() method.
 *
 * The function will fail if the thread is currently running or has finished
 * but no join() has been called.
 *//*--------------------------------------------------------------------*/
void Thread::start (void)
{
	DE_ASSERT(!m_thread);
	m_thread = deThread_create(threadFunc, this, &m_attribs);
	if (!m_thread)
		throw std::bad_alloc();
}
Ejemplo n.º 15
0
IterateResult NumLayersTest::build (FboBuilder& builder)
{
	TextureLayered* texCfg = DE_NULL;
	const GLenum target = GL_COLOR_ATTACHMENT0;

	switch (m_params.textureKind)
	{
		case GL_TEXTURE_3D:
			texCfg = &builder.makeConfig<Texture3D>();
			break;
		case GL_TEXTURE_2D_ARRAY:
			texCfg = &builder.makeConfig<Texture2DArray>();
			break;
		default:
			DE_ASSERT(!"Impossible case");
	}
	texCfg->internalFormat = getDefaultFormat(target, GL_TEXTURE);
	texCfg->width = 64;
	texCfg->height = 64;
	texCfg->numLayers = m_params.numLayers;
	const GLuint tex = builder.glCreateTexture(*texCfg);

	TextureLayerAttachment* att = &builder.makeConfig<TextureLayerAttachment>();
	att->layer = m_params.attachmentLayer;
	att->imageName = tex;

	builder.glAttach(target, att);

	return STOP;
}
void ContainerFormatParser::parseContainerValue (std::string& dst, int& offset) const
{
	DE_ASSERT(offset < m_elementLen);

	bool	isString	= getChar(offset) == '"' || getChar(offset) == '\'';
	int		quotChar	= isString ? getChar(offset) : 0;

	if (isString)
		offset += 1;

	dst.clear();

	for (;;)
	{
		int		curChar		= offset < m_elementLen ? getChar(offset) : 0;
		bool	isEnd		= curChar == 0 || curChar == (int)END_OF_BUFFER ||
							  (isString ? (curChar == quotChar) : (curChar == ' ' || curChar == '\n' || curChar == '\r'));

		if (isEnd)
			break;
		else
		{
			// \todo [2012-06-09 pyry] Escapes.
			dst.push_back((char)curChar);
		}

		offset += 1;
	}

	if (isString && getChar(offset) == quotChar)
		offset += 1;
}
Ejemplo n.º 17
0
void deTimer_destroy (deTimer* timer)
{
	DE_ASSERT(timer);

	timer_delete(timer->timer);
	deFree(timer);
}
Ejemplo n.º 18
0
void deMutex_destroy (deMutex mutex)
{
	pthread_mutex_t* pMutex = (pthread_mutex_t*)mutex;
	DE_ASSERT(pMutex);
	pthread_mutex_destroy(pMutex);
	deFree(pMutex);
}
Ejemplo n.º 19
0
static deTimerThread* deTimerThread_create (deTimerCallback callback, void* arg, int interval, TimerState state)
{
	deTimerThread* thread = (deTimerThread*)deCalloc(sizeof(deTimerThread));

	DE_ASSERT(state == TIMERSTATE_INTERVAL || state == TIMERSTATE_SINGLE);

	if (!thread)
		return DE_NULL;

	thread->callback	= callback;
	thread->callbackArg	= arg;
	thread->interval	= interval;
	thread->lock		= deMutex_create(DE_NULL);
	thread->state		= state;

	thread->thread		= deThread_create(timerThread, thread, DE_NULL);
	if (!thread->thread)
	{
		deMutex_destroy(thread->lock);
		deFree(thread);
		return DE_NULL;
	}

	return thread;
}
DE_BEGIN_EXTERN_C

JNIEXPORT void JNICALL Java_com_drawelements_deqp_execserver_ExecService_onCreateNative (JNIEnv* env, jobject obj)
{
	tcu::Android::ExecService*	service		= DE_NULL;
	JavaVM*						vm			= DE_NULL;

	try
	{
		DE_ASSERT(!getExecService(env, obj));

		env->GetJavaVM(&vm);
		TCU_CHECK_INTERNAL(vm);

		service = new tcu::Android::ExecService(vm, obj);
		service->start();

		setExecService(env, obj, service);
	}
	catch (const std::exception& e)
	{
		logException(e);
		delete service;
		tcu::die("ExecService.onCreateNative() failed");
	}
}
static void inStreamCopy (void* arg)
{
	deThreadInStream* threadStream = (deThreadInStream*)arg;

	deUint8* buffer = malloc(sizeof(deUint8) * threadStream->bufferSize);

	for(;;)
	{
		deInt32 read	= 0;
		deInt32 written	= 0;
		deStreamResult readResult = DE_STREAMRESULT_ERROR;

		readResult = deInStream_read(threadStream->input, buffer, threadStream->bufferSize, &read);
		DE_ASSERT(readResult != DE_STREAMRESULT_ERROR);
		while (written < read)
		{
			deInt32 wrote = 0;

			/* \todo [mika] Handle errors */
			deOutStream_write(&(threadStream->producerStream), buffer, read - written, &wrote);

			written += wrote;
		}

		if (readResult == DE_STREAMRESULT_END_OF_STREAM)
		{
			break;
		}
	}

	deOutStream_flush(&(threadStream->producerStream));
	deRingbuffer_stop(threadStream->ringbuffer);
	free(buffer);

}
inline void RingBuffer<T>::pushFront (const T& elem)
{
	DE_ASSERT(getNumFree() > 0);
	m_buffer[m_front] = elem;
	m_front = (m_front + 1) % m_size;
	m_numElements += 1;
}
void deSemaphore_destroy (deSemaphore semaphore)
{
	sem_t* sem = (sem_t*)semaphore;
	DE_ASSERT(sem);
	sem_destroy(sem);
	deFree(sem);
}
static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet)
{
	DE_ASSERT(testSet.hasNode(node));

	TestNodeType nodeType = node->getNodeType();

	if (nodeType != TESTNODETYPE_ROOT)
		str << node->getName();

	if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP)
	{
		const TestGroup*	group	= static_cast<const TestGroup*>(node);
		bool				isFirst	= true;

		str << "{";

		for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
		{
			const TestNode* child = group->getChild(ndx);

			if (testSet.hasNode(child))
			{
				if (!isFirst)
					str << ",";

				writeCaseListNode(str, child, testSet);
				isFirst = false;
			}
		}

		str << "}";
	}
}
void deSemaphore_decrement (deSemaphore semaphore)
{
	sem_t*	sem	= (sem_t*)semaphore;
	int		ret	= sem_wait(sem);
	DE_ASSERT(ret == 0);
	DE_UNREF(ret);
}
Ejemplo n.º 26
0
void VarTokenizer::advance (void)
{
	DE_ASSERT(m_token != TOKEN_END);

	m_tokenStart	+= m_tokenLen;
	m_token			 = TOKEN_LAST;
	m_tokenLen		 = 1;

	if (m_str[m_tokenStart] == '[')
		m_token = TOKEN_LEFT_BRACKET;
	else if (m_str[m_tokenStart] == ']')
		m_token = TOKEN_RIGHT_BRACKET;
	else if (m_str[m_tokenStart] == 0)
		m_token = TOKEN_END;
	else if (m_str[m_tokenStart] == '.')
		m_token = TOKEN_PERIOD;
	else if (isNum(m_str[m_tokenStart]))
	{
		m_token = TOKEN_NUMBER;
		while (isNum(m_str[m_tokenStart+m_tokenLen]))
			m_tokenLen += 1;
	}
	else if (isIdentifierChar(m_str[m_tokenStart]))
	{
		m_token = TOKEN_IDENTIFIER;
		while (isIdentifierChar(m_str[m_tokenStart+m_tokenLen]))
			m_tokenLen += 1;
	}
	else
		TCU_FAIL("Unexpected character");
}
void ContainerFormatParser::advance (void)
{
	if (m_element != CONTAINERELEMENT_INCOMPLETE)
	{
		m_buf.popBack(m_elementLen);

		m_element		= CONTAINERELEMENT_INCOMPLETE;
		m_elementLen	= 0;
		m_attribute.clear();
		m_value.clear();
	}

	for (;;)
	{
		int curChar = getChar(m_elementLen);

		if (curChar != (int)END_OF_BUFFER)
			m_elementLen += 1;

		if (curChar == END_OF_STRING)
		{
			if (m_elementLen == 1)
				m_element = CONTAINERELEMENT_END_OF_STRING;
			else if (m_state == STATE_CONTAINER_LINE)
				parseContainerLine();
			else
				m_element = CONTAINERELEMENT_TEST_LOG_DATA;

			break;
		}
		else if (curChar == (int)END_OF_BUFFER)
		{
			if (m_elementLen > 0 && m_state == STATE_DATA)
				m_element = CONTAINERELEMENT_TEST_LOG_DATA;

			break;
		}
		else if (curChar == '\r' || curChar == '\n')
		{
			// Check for \r\n
			int nextChar = getChar(m_elementLen);
			if (curChar == '\n' || (nextChar != (int)END_OF_BUFFER && nextChar != '\n'))
			{
				if (m_state == STATE_CONTAINER_LINE)
					parseContainerLine();
				else
					m_element = CONTAINERELEMENT_TEST_LOG_DATA;

				m_state = STATE_AT_LINE_START;
				break;
			}
			// else handle following end or \n in next iteration.
		}
		else if (m_state == STATE_AT_LINE_START)
		{
			DE_ASSERT(m_elementLen == 1);
			m_state = (curChar == '#') ? STATE_CONTAINER_LINE : STATE_DATA;
		}
	}
}
void deSemaphore_decrement (deSemaphore semaphore)
{
	sem_t*	sem		= ((NamedSemaphore*)semaphore)->semaphore;
	int		res		= sem_wait(sem);
	DE_ASSERT(res == 0);
	DE_UNREF(res);
}
Ejemplo n.º 29
0
deBool qpTestLog_endSampleList (qpTestLog* log)
{
	DE_ASSERT(log);
	deMutex_lock(log->lock);

	if (!qpXmlWriter_endElement(log->writer, "SampleList"))
	{
		qpPrintf("qpTestLog_endSampleList(): Writing XML failed\n");
		deMutex_unlock(log->lock);
		return DE_FALSE;
	}

	DE_ASSERT(ContainerStack_pop(&log->containerStack) == CONTAINERTYPE_SAMPLELIST);

	deMutex_unlock(log->lock);
	return DE_TRUE;
}
Ejemplo n.º 30
0
deBool qpTestLog_startSampleInfo (qpTestLog* log)
{
	DE_ASSERT(log);
	deMutex_lock(log->lock);

	if (!qpXmlWriter_startElement(log->writer, "SampleInfo", 0, DE_NULL))
	{
		qpPrintf("qpTestLog_startSampleInfo(): Writing XML failed\n");
		deMutex_unlock(log->lock);
		return DE_FALSE;
	}

	DE_ASSERT(ContainerStack_push(&log->containerStack, CONTAINERTYPE_SAMPLEINFO));

	deMutex_unlock(log->lock);
	return DE_TRUE;
}