/*
* call-seq:
* Memory.create_subbuffer(buffer, , [10, 100])
*
*/
static VALUE
rcl_mem_create_subbuffer(VALUE mod, VALUE buffer,
VALUE flags,
VALUE region)
{
EXPECT_RCL_TYPE(buffer, Memory);
EXPECT_FIXNUM(flags);
EXPECT_ARRAY(region);
long i = RARRAY_LEN(region);
if (i != 2) {
rb_raise(rb_eArgError, "Expected the parameter region has 2 items, got (%ld).", i);
}
VALUE sz = rb_ary_entry(region, 0);
EXTRACT_SIZE(sz, origin);
sz = rb_ary_entry(region, 1);
EXTRACT_SIZE(sz, offset);
cl_buffer_region br;
br.origin = origin;
br.size = offset;
cl_mem buf = MemoryPtr(buffer);
cl_mem_flags mf = FIX2INT(flags);
cl_int res = CL_SUCCESS;
cl_mem subbuf = clCreateSubBuffer(buf, mf, CL_BUFFER_CREATE_TYPE_REGION, &br, &res);
CHECK_AND_RAISE(res);
return RMemory(subbuf);
}
static VALUE
rcl_mem_image_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_image_info ii = FIX2UINT(param_name);
cl_mem m = MemoryPtr(self);
cl_image_format imgfmt;
cl_int res = clGetImageInfo(m, ii, sizeof(cl_image_format), (void *)&imgfmt, NULL);
CHECK_AND_RAISE(res);
switch (ii) {
case CL_IMAGE_FORMAT:
return RImageFormat(&imgfmt);
case CL_IMAGE_ELEMENT_SIZE:
case CL_IMAGE_ROW_PITCH:
case CL_IMAGE_SLICE_PITCH:
case CL_IMAGE_WIDTH:
case CL_IMAGE_HEIGHT:
case CL_IMAGE_DEPTH:
return ULONG2NUM(*(size_t *)&imgfmt);
}
return Qnil;
}
static VALUE
rcl_mem_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_mem_info mi = FIX2UINT(param_name);
cl_mem m = MemoryPtr(self);
intptr_t param_value;
cl_int res = clGetMemObjectInfo(m, mi, sizeof(intptr_t), ¶m_value, NULL);
CHECK_AND_RAISE(res);
switch (mi) {
case CL_MEM_TYPE:
case CL_MEM_FLAGS:
case CL_MEM_SIZE:
case CL_MEM_MAP_COUNT:
case CL_MEM_REFERENCE_COUNT:
return UINT2NUM(param_value);
case CL_MEM_HOST_PTR: // CHECK: Should be wrapped to a HostPoiner? MappedPointer? No.
return ULONG2NUM(param_value);
case CL_MEM_CONTEXT:
return RContext((cl_context)param_value);
default:
break;
}
return Qnil;
}
//---------------------------------------------------------------------------
long PacketFile::afterOpen (void)
{
if (!numPackets && getLength() >= 12)
{
long firstPacketOffset;
long firstCheck = readLong();
if (firstCheck == PACKET_FILE_VERSION && !usesCheckSum)
{
}
else
{
//---------------------------------------
// This is probably a checksum. Check it
long checkSum = checkSumFile();
if (checkSum != firstCheck)
return PACKET_OUT_OF_RANGE;
}
firstPacketOffset = readLong();
numPackets = (firstPacketOffset/sizeof(long))-2;
}
currentPacket = -1;
if (fileMode == READ || fileMode == RDWRITE)
{
if (numPackets && !seekTable)
{
//seekTable = (long *)systemHeap->Malloc(numPackets * sizeof(long));
seekTable = new long[numPackets]; //magic 02102011
gosASSERT(seekTable != NULL);
seek(sizeof(long)*2); //File Version & File Length
read(MemoryPtr(seekTable),(numPackets*sizeof(long)));
}
}
return(NO_ERR);
}
//---------------------------------------------------------------------------
void PacketFile::reserve (long count, bool useCheckSum)
{
//---------------------------------------------------
// If we already have packets, reserve does nothing.
// Otherwise, reserve sets up the file. Must be
// called before any writing to a newly created file.
if (numPackets)
{
return;
}
usesCheckSum = useCheckSum;
numPackets = count;
long firstPacketOffset = TABLE_ENTRY(numPackets);
writeLong(PACKET_FILE_VERSION);
writeLong(firstPacketOffset);
//----------------------------
// initialize the seek table
while (count-- > 0)
writeLong(SetPacketType(firstPacketOffset,STORAGE_TYPE_NUL));
//-------------------------------------------------------------
// If we called this, chances are we are writing a packet file
// from start to finish. It is MUCH faster if this table is
// updated in memory and flushed when the file is closed.
if (!seekTable)
{
//seekTable = (long *)systemHeap->Malloc(numPackets * sizeof(long));
seekTable = new long[numPackets]; //magic 02102011
if (seekTable != NULL)
{
seek(sizeof(long)*2); //File Version & File Length
read(MemoryPtr(seekTable),(numPackets*sizeof(long)));
}
}
}
//---------------------------------------------------------------------------
void PacketFile::atClose (void)
{
if (isOpen() && fileMode != READ) // update filesize
{
long endPtr = getLength();
//seek(sizeof(long)); //Move Past Version Marker
//writeLong(endPtr); //Write File length
long tableEntry;
currentPacket = numPackets;
if (!seekTable)
{
while (--currentPacket >= 0)
{
seek(TABLE_ENTRY(currentPacket));
tableEntry = readLong();
if (GetPacketType(tableEntry) == STORAGE_TYPE_NUL)
{
seek(TABLE_ENTRY(currentPacket));
writeLong(SetPacketType(endPtr,STORAGE_TYPE_NUL));
}
else
{
endPtr = GetPacketOffset(tableEntry);
}
}
}
else
{
while (--currentPacket >= 0)
{
tableEntry = seekTable[currentPacket];
if (GetPacketType(tableEntry) == STORAGE_TYPE_NUL)
{
seekTable[currentPacket] = SetPacketType(endPtr,STORAGE_TYPE_NUL);
}
else
{
endPtr = GetPacketOffset(tableEntry);
}
}
}
//-----------------------------------------------------
// If seekTable was being used, write it back to file
if (seekTable)
{
seek(sizeof(long)*2); //File Version & File Length
write(MemoryPtr(seekTable),(numPackets*sizeof(long)));
}
//------------------------------------------------------
// Is we were using a checkSum, calc it and write it to
// the beginning of the file.
if (usesCheckSum)
{
long checkSum = checkSumFile();
seek(0);
writeLong(checkSum);
}
}
clear();
}
