Esempio n. 1
0
int SharedDataManager::getSegmentInfo(TreeDescriptor treeIdx, int nid, int idx, int **shape, int *shapeSize, int *currDataSize)
{
	Segment *segment;
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeIdx, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			lock.unlock();
			return 0;
		}
		int numSegments = nodeData->getNumSegments();
		if(idx >= numSegments)
			idx = numSegments - 1;
		segment = nodeData->getSegmentAt(idx);
		segment->getShape(reinterpret_cast<char **>(shape), shapeSize);
		*currDataSize = segment->getCurrDataSize();
		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 2
0
int SharedDataManager::getSegmentData(TreeDescriptor treeId, int nid, int idx, char **dim, int *dimSize, char **data, int *dataSize,
									  char **shape, int *shapeSize, int *currDataSize, bool *timestamped, int *actSamples)
{
	Segment *segment;
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			lock.unlock();
			return 0;
		}
		int numSegments = nodeData->getNumSegments();
		if(idx >= numSegments || idx < 0)
		{
			lock.unlock();
			return 0;
		}
		segment = nodeData->getSegmentAt(idx);

		segment->getDim((char **)dim, dimSize);
		segment->getData((char **)data, dataSize);
		segment->getShape((char **)shape, shapeSize);
		*currDataSize = segment->getCurrDataSize();
		*timestamped = segment->isTimestamped();
		*actSamples = segment->getActSamples();

		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 3
0
int SharedDataManager::getNumSegments(TreeDescriptor treeId, int nid, int *numSegments)
{
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		*numSegments = nodeData->getNumSegments();
		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 4
0
int SharedDataManager::getSegmentLimits(TreeDescriptor treeId, int nid, int idx, char **start, int *startSize, 
		char **end, int *endSize, bool *timestamped)
{
	Segment *segment;
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			lock.unlock();
			return 0;
		}
		int numSegments = nodeData->getNumSegments();
		if(idx >= numSegments || idx < 0)
		{
			lock.unlock();
			return 0;
		}
		segment = nodeData->getSegmentAt(idx);

		if(segment->isTimestamped())
		{
			*timestamped = true;
			segment->getStartTimestamp(start, startSize);
			segment->getEndTimestamp(end, endSize);
		}
		else
		{
			segment->getStart((char **)start, startSize);
			segment->getEnd((char **)end, endSize);
			*timestamped = false;
		}
		
		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 5
0
int SharedDataManager::findSegment(TreeDescriptor treeId, int nid, int *retIdx)
{
	int numSegments;

	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		numSegments = nodeData->getNumSegments();
		if(numSegments == 0) 
		{
			lock.unlock();
			return 0; //No segments
		}
		*retIdx = numSegments - 1;
		lock.unlock();
		return 1;
	}
	return 0;
}
Esempio n. 6
0
int SharedDataManager::getSegmentDataAndShapeCopy(TreeDescriptor treeId, int nid, int idx, char **data, int *dataSize,
									  char **shape, int *shapeSize)
{
	Segment *segment;
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			lock.unlock();
			return 0;
		}
		int numSegments = nodeData->getNumSegments();
		if(idx >= numSegments || idx < 0)
		{
			lock.unlock();
			return 0;
		}
		segment = nodeData->getSegmentAt(idx);

		char *currData;
		segment->getData((char **)&currData, dataSize);
		*data = new char[*dataSize];
		memcpy(*data, currData,*dataSize);
		char *currShape;
		segment->getShape((char **)&currShape, shapeSize);
		*shape = new char[*shapeSize];
		memcpy(*shape, currShape, *shapeSize);

		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 7
0
int SharedDataManager::updateSegment(TreeDescriptor treeId, int nid, int idx, char *start, int startSize, char *end, int endSize, 
								  char *dim, int dimSize)
{
	Segment *segment;
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			lock.unlock();
			return 0;
		}
		int numSegments = nodeData->getNumSegments();
		if(idx > numSegments || idx < 0)
		{
			lock.unlock();
			return 0;
		}
		segment = nodeData->getSegmentAt(idx);

		char *currPtr;
		int currSize;
		segment->getStart(&currPtr, &currSize);
		if(startSize > 0)
		{
		    if(currSize > 0)
			allocationManager.deallocateShared((char *)currPtr, currSize);
		    currPtr = allocationManager.allocateShared(startSize);
		    memcpy(currPtr, start, startSize);
		    segment->setStart(currPtr, startSize);
		}
		if(endSize > 0)
		{
		    segment->getEnd(&currPtr, &currSize);
		    if(currSize > 0)
			allocationManager.deallocateShared((char *)currPtr, currSize);
		    currPtr = allocationManager.allocateShared(endSize);
		    memcpy(currPtr, end, endSize);
		    segment->setEnd(currPtr, endSize);
		}
		
		if(dimSize > 0)
		{
		    segment->getDim(&currPtr, &currSize);
		    if(currSize > 0)
			allocationManager.deallocateShared((char *)currPtr, currSize);
		    currPtr = allocationManager.allocateShared(dimSize);
		    memcpy(currPtr, dim, dimSize);
		    segment->setDim(currPtr, dimSize);
  		}
		CallbackManager *callback = node->getData()->getCallbackManager();
		if(callback)
			callback->callCallback();
		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 8
0
/*
//Return Shape and type information. The coding is the following:
//1) data type
//2) item size in bytes
//3) number of dimensions 
//4) total dimension in bytes 
//The remaining elements are the dimension limits

*/
int SharedDataManager::appendSegmentData(TreeDescriptor treeId, int nid, int *bounds, int boundsSize, char *data, 
										 int dataSize, int idx, int startIdx, 
										 bool isTimestamped, _int64 *timestamps, int numTimestamps, int *segmentFilled, 
										 int *retIdx)
{
	int numSegments;
	int *shape;
	int shapeSize;
	char *segmentData;
	int segmentSize;

	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(!node)
	{
		SharedMemNodeData nodeData;
		nodeData.setNid(treeId, nid);
		nodeData.setSegmented(true);
		sharedTree.insert(&nodeData);
		node = sharedTree.find(treeId, nid);
	}
	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		numSegments = nodeData->getNumSegments();
		if(numSegments == 0) //May happen the first time putRow is called
		{
			lock.unlock();
			
		//	printf("APPENDSEGMENT DATA: NO SEGMENTS");
			
			return TRUNCATED;
		}

		if(idx >= numSegments || numSegments == 0)
		{
			lock.unlock();
//			printf("APPENDSEGMENT DATA: BAD INDEX");
			return BAD_INDEX;
		}
		Segment *segment = nodeData->getSegmentAt(idx);
/*		if(!segment->isTimestamped())
		{
		    lock.unlock();
		    return 0;
		}
*/		
		segment->getShape((char **)&shape, &shapeSize);
		//Check Shape. Meaning of bound array:
//		1) data type
//		2) item size in bytes
//		3) number of dimensions 
//		4) total dimension in bytes 
//		The remaining elements are the dimension limits
		if(bounds[0] != shape[0])
		{
			lock.unlock();
//			printf("APPENDSEGMENT DATA: BAD TYPE %d   %d\n", bounds[0], shape[0]);
			return BAD_TYPE;
		}
		if(bounds[2] < shape[2] - 1 || bounds[2] > shape[2])
		{
			lock.unlock();
//			printf("APPENDSEGMENT DATA: BAD TYPE 1");
			return BAD_SHAPE;
		}

		for(int i = 0; i < shape[2] - 1; i++)
		{
			if(bounds[4 + i] != shape[4 + i])
			{
				lock.unlock();
//			printf("APPENDSEGMENT DATA: BAD SHAPE");
				return BAD_SHAPE;
			}
		}
		int currSegmentSize = segment->getCurrDataSize();
		segment->getData((char **)&segmentData, &segmentSize);
		if(startIdx < 0)
		{
			int leftSize = segmentSize - currSegmentSize;
			if(dataSize > leftSize)
			{
				lock.unlock();
	//		printf("APPENDSEGMENT DATA: DATASIZE > LEFT SIZE");
				return TRUNCATED;
			}
			if(leftSize == dataSize)
				*segmentFilled = 1;
			else
				*segmentFilled = 0;

			memcpy(&segmentData[currSegmentSize], data, dataSize);
			segment->setCurrDataSize(currSegmentSize + dataSize);
			if(isTimestamped)
				segment->appendTimestamps(timestamps, numTimestamps);
			*retIdx = numSegments - 1;
			CallbackManager *callback = node->getData()->getCallbackManager();

			if(callback)
				callback->callCallback();
			lock.unlock();
			return 1;
		}
		else
		{
			int itemSize = bounds[3]; //Total size of a data item (array)
			int startOfs = startIdx * itemSize;
			int leftSize = segmentSize - startOfs;
			if(dataSize > leftSize)
			{
				lock.unlock();
//			printf("APPENDSEGMENT DATA: DATASIZE > LEFT SIZE");
				return TRUNCATED;
			}
			if(leftSize == dataSize)
				*segmentFilled = 1;
			else
				*segmentFilled = 0;
			memcpy(&segmentData[startOfs], data, dataSize);
			*retIdx = numSegments - 1;
			//Segment size does not change
			CallbackManager *callback = node->getData()->getCallbackManager();
			if(callback)
				callback->callCallback();
			lock.unlock();
			return 1;
		}
	}
	lock.unlock();
	return 0;
}
Esempio n. 9
0
int SharedDataManager::beginTimestampedSegment(TreeDescriptor treeId, int nid, int idx, int numItems, char *shape, 
											   int shapeSize, char *data, int dataSize, _int64 start, 
											   _int64 end, char *dim, int dimSize, int *retIdx)
{
	Segment *segment;
//printf("BEGIN TIMESTAMPED SEGMENT SHARE: %d\n", *(int *)shape);
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(!node)
	{
		SharedMemNodeData nodeData;
		nodeData.setNid(treeId, nid);
		nodeData.setSegmented(true);
		sharedTree.insert(&nodeData);
		node = sharedTree.find(treeId, nid);
	}

	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			nodeData->free(&allocationManager);
			nodeData->setSegmented(true);
		}
		int numSegments = nodeData->getNumSegments();
		if(idx > numSegments)
		{
			lock.unlock();
			return 0;
		}
		if(idx == numSegments || idx < 0)
		{
			segment = (Segment *)allocationManager.allocateShared(sizeof(Segment));
			
//			printf("ALLOCATED SEGMENT: %x\n", segment);
			
			segment->initialize();
			nodeData->appendSegment(segment);
			*retIdx = numSegments;
		}
		else
		{
			segment = nodeData->getSegmentAt(idx);
			*retIdx = idx;
		}

		char *currPtr;
		segment->free(&allocationManager);

		if(dimSize == 0)
		{
			currPtr = allocationManager.allocateShared(8 * numItems);
//			printf("ALLOCATED SEGMENT DIM: %x\n", currPtr);
			segment->setDim(currPtr, 8 * numItems);
		}
		currPtr = allocationManager.allocateShared(shapeSize);
//			printf("ALLOCATED SEGMENT SHAPE: %x  %d\n", currPtr, *(int *)shape);
		memcpy(currPtr, shape, shapeSize);
		segment->setShape(currPtr, shapeSize);

		currPtr = allocationManager.allocateShared(dataSize);
//			printf("ALLOCATED SEGMENTDATA: %x\n", currPtr);
		memcpy(currPtr, data, dataSize);
		segment->setData(currPtr, dataSize);
	
		//The following parameters are meaningful only when copying a segment from the tree into cache
		segment->setStartTimestamp(start);
		segment->setEndTimestamp(end);
		if(dimSize > 0)
		{
			currPtr = allocationManager.allocateShared(dimSize);
//			printf("ALLOCATED SEGMENT DIM : %x\n", currPtr);
			memcpy(currPtr, dim, dimSize);
			segment->setDim(currPtr, dimSize);
			segment->setStartTimestamp(*(_int64 *)dim);
			if(end == 0) segment->setEndTimestamp(*(_int64 *)dim);
		}
		segment->setTimestamped(true);

		lock.unlock();
//printf("END BEGIN TIMESTAMPED SEGMENT LAST SEGMENT: %x\n", nodeData->getLastSegment());
		return 1;
	}
	lock.unlock();
	return 0;
}
Esempio n. 10
0
int SharedDataManager::beginSegment(TreeDescriptor treeId, int nid, int idx, char *start, int startSize, char *end, int endSize, 
			char *dim, int dimSize, char *shape, int shapeSize, char *data, int dataSize, int *retIdx)
{
	Segment *segment;
	lock.lock();
	SharedMemNode *node = sharedTree.find(treeId, nid);
	if(!node)
	{
		SharedMemNodeData nodeData;
		nodeData.setNid(treeId, nid);
		nodeData.setSegmented(true);
		sharedTree.insert(&nodeData);
		node = sharedTree.find(treeId, nid);
	}

	if(node)
	{
		SharedMemNodeData *nodeData = node->getData();
		if(!nodeData->isSegmented())
		{
			nodeData->free(&allocationManager);
			nodeData->setSegmented(true);
		}
		int numSegments = nodeData->getNumSegments();
		if(idx > numSegments)
		{
			lock.unlock();
			return 0;
		}
		if(idx == numSegments || idx < 0)
		{
			segment = (Segment *)allocationManager.allocateShared(sizeof(Segment));
			segment->initialize();
			nodeData->appendSegment(segment);
			*retIdx = numSegments;
		}
		else
		{
			segment = nodeData->getSegmentAt(idx);
			*retIdx = idx;
		}

		char *currPtr;
		segment->free(&allocationManager);

		currPtr = allocationManager.allocateShared(startSize);
		memcpy(currPtr, start, startSize);
		segment->setStart(currPtr, startSize);

		currPtr = allocationManager.allocateShared(endSize);
		memcpy(currPtr, end, endSize);
		segment->setEnd(currPtr, endSize);

		currPtr = allocationManager.allocateShared(dimSize);
		memcpy(currPtr, dim, dimSize);
		segment->setDim(currPtr, dimSize);

		currPtr = allocationManager.allocateShared(shapeSize);
		memcpy(currPtr, shape, shapeSize);
		segment->setShape(currPtr, shapeSize);

		currPtr = allocationManager.allocateShared(dataSize);
		memcpy(currPtr, data, dataSize);
		segment->setData(currPtr, dataSize);

		segment->setTimestamped(false);

		lock.unlock();
		return 1;
	}
	lock.unlock();
	return 0;
}