static int cuda_FloatTensor_fakecopy(lua_State *L)
{
THFloatTensor *self = luaT_checkudata(L, 1, "torch.FloatTensor");
THFloatTensor *src = luaT_checkudata(L, 2, "torch.FloatTensor");
long *d_self_sz, *d_self_st, *d_src_sz, *d_src_st;
long nElement = THFloatTensor_nElement(self);
THArgCheck(THFloatTensor_nElement(self) == THFloatTensor_nElement(src), 2, "sizes do not match");
THFloatTensor_computesz(self, &d_self_sz, &d_self_st);
THFloatTensor_computesz(src, &d_src_sz, &d_src_st);
THFloatTensor_kernel_copy(THFloatTensor_data(self),
d_self_sz, d_self_st, self->nDimension,
THFloatTensor_data(src),
d_src_sz, d_src_st, src->nDimension,
nElement);
THFree(d_self_sz);
THFree(d_self_st);
THFree(d_src_sz);
THFree(d_src_st);
lua_settop(L, 1);
return 1;
}
static void THDiskFile_free(THFile *self)
{
THDiskFile *dfself = (THDiskFile*)(self);
if(dfself->handle)
fclose(dfself->handle);
THFree(dfself->name);
THFree(dfself);
}
void transfer_tensor(THByteTensor *dst, THByteTensor *src) {
if (dst->storage)
THFree(dst->storage);
if (dst->size)
THFree(dst->size);
if (dst->stride)
THFree(dst->stride);
dst->storage = src->storage;
dst->size = src->size;
dst->stride = src->stride;
dst->nDimension = src->nDimension;
++dst->refcount;
}
void* THRealloc(void *ptr, ptrdiff_t size)
{
if(!ptr)
return(THAlloc(size));
if(size == 0)
{
THFree(ptr);
return NULL;
}
if(size < 0)
THError("$ Torch: invalid memory size -- maybe an overflow?");
ptrdiff_t oldSize = -getAllocSize(ptr);
void *newptr = realloc(ptr, size);
if(!newptr && torchGCFunction) {
torchGCFunction(torchGCData);
newptr = realloc(ptr, size);
}
if(!newptr)
THError("$ Torch: not enough memory: you tried to reallocate %dGB. Buy new RAM!", size/1073741824);
// update heapSize only after successfully reallocated
THHeapUpdate(oldSize + getAllocSize(newptr));
return newptr;
}
void* THRealloc(void *ptr, long size)
{
if(!ptr)
return(THAlloc(size));
if(size == 0)
{
THFree(ptr);
return NULL;
}
if(size < 0)
THError("$ Torch: invalid memory size -- maybe an overflow?");
THHeapUpdate(-getAllocSize(ptr));
void *newptr = realloc(ptr, size);
if(!newptr && torchGCFunction) {
torchGCFunction(torchGCData);
newptr = realloc(ptr, size);
}
THHeapUpdate(getAllocSize(newptr ? newptr : ptr));
if(!newptr)
THError("$ Torch: not enough memory: you tried to reallocate %dGB. Buy new RAM!", size/1073741824);
return newptr;
}
void THCudaTensor_free(THCState *state, THCudaTensor *self)
{
if(!self)
return;
if(self->flag & TH_TENSOR_REFCOUNTED)
{
if(THAtomicDecrementRef(&self->refcount))
{
THFree(self->size);
THFree(self->stride);
if(self->storage)
THCudaStorage_free(state, self->storage);
THFree(self);
}
}
}
void THCudaTensor_free(THCState *state, THCudaTensor *self)
{
if(!self)
return;
if(self->flag & TH_TENSOR_REFCOUNTED)
{
if(--self->refcount == 0)
{
THFree(self->size);
THFree(self->stride);
if(self->storage)
THCudaStorage_free(state, self->storage);
THFree(self);
}
}
}
static void THMemoryFile_free(THFile *self)
{
THMemoryFile *mfself = (THMemoryFile*)self;
if(mfself->storage)
THCharStorage_free(mfself->storage);
THFree(mfself);
}
void THCudaTensor_unfold(THCState *state, THCudaTensor *self, THCudaTensor *src, int dimension, long size, long step)
{
long *newSize;
long *newStride;
int d;
if(!src)
src = self;
THArgCheck( (src->nDimension > 0), 1, "cannot unfold an empty tensor");
THArgCheck(dimension < src->nDimension, 2, "out of range");
THArgCheck(size <= src->size[dimension], 3, "out of range");
THArgCheck(step > 0, 4, "invalid step");
THCudaTensor_set(state, self, src);
newSize = (long*)THAlloc(sizeof(long)*(self->nDimension+1));
newStride = (long*)THAlloc(sizeof(long)*(self->nDimension+1));
newSize[self->nDimension] = size;
newStride[self->nDimension] = self->stride[dimension];
for(d = 0; d < self->nDimension; d++)
{
if(d == dimension)
{
newSize[d] = (self->size[d] - size) / step + 1;
newStride[d] = step*self->stride[d];
}
else
{
newSize[d] = self->size[d];
newStride[d] = self->stride[d];
}
}
THFree(self->size);
THFree(self->stride);
self->size = newSize;
self->stride = newStride;
self->nDimension++;
}
void THCudaStorage_free(THCudaStorage *self)
{
if(!(self->flag & TH_STORAGE_REFCOUNTED))
return;
if (--(self->refcount) <= 0)
{
if(self->flag & TH_STORAGE_FREEMEM)
THCudaCheck(cudaFree(self->data));
THFree(self);
}
}
void THCStorage_free(THCState *state, THCStorage *self)
{
if(!(self->flag & TH_STORAGE_REFCOUNTED))
return;
if (--self->refcount == 0)
{
if(self->flag & TH_STORAGE_FREEMEM) {
THCudaCheck(
(*self->allocator->free)(self->allocatorContext, self->data_ptr));
}
if(self->flag & TH_STORAGE_VIEW) {
THCStorage_free(state, self->view);
}
self->refcount.~atomic<int>();
THFree(self);
}
}
void* THRealloc(void *ptr, long size)
{
if(!ptr)
return(THAlloc(size));
if(size == 0)
{
THFree(ptr);
return NULL;
}
if(size < 0)
THError("$ Torch: invalid memory size -- maybe an overflow?");
ptr = realloc(ptr, size);
if(!ptr)
THError("$ Torch: not enough memory: you tried to reallocate %dGB. Buy new RAM!", size/1073741824);
return ptr;
}
static void THFloatTensor_computesz(THFloatTensor *self, long **sz_, long **st_)
{
long *sz, *st, *szh;
int i;
sz = THAlloc(sizeof(long)*self->nDimension);
st = THAlloc(sizeof(long)*self->nDimension);
szh = THAlloc(sizeof(long)*self->nDimension);
for(i = self->nDimension-1; i >= 0; i--)
{
if(i == self->nDimension-1)
szh[i] = 1;
else
szh[i] = szh[i+1]*self->size[i+1];
}
memcpy(sz, szh, self->nDimension * sizeof(long));
memcpy(st, self->stride, self->nDimension * sizeof(long));
THFree(szh);
*sz_ = sz;
*st_ = st;
}
static void THDefaultAllocator_free(void* ctx, void* ptr) {
THFree(ptr);
}
void THMapAllocatorContext_free(THMapAllocatorContext *ctx)
{
if (ctx->filename != unknown_filename)
THFree(ctx->filename);
THFree(ctx);
}
static void THNN_(SpatialFractionalMaxPooling_updateOutput_frame)(
real* input,
real* output,
real* indices,
real* randomSamples,
long numPlanes,
long inputW, long inputH,
long outputW, long outputH,
int poolSizeW, int poolSizeH) {
long plane;
#pragma omp parallel for private(plane)
for (plane = 0; plane < numPlanes; ++plane) {
/* each plane contains 2 random samples, one for W and one for H */
real* randomSamplesForPlane = randomSamples + plane * 2;
/* Generate interval sequence */
long* sequenceW =
THNN_(SpatialFractionalMaxPooling_generateIntervals)(
randomSamplesForPlane[0], inputW, outputW, poolSizeW);
long* sequenceH =
THNN_(SpatialFractionalMaxPooling_generateIntervals)(
randomSamplesForPlane[1], inputH, outputH, poolSizeH);
/* loop over output */
long h, w;
real* inputForPlane = input + plane * inputW * inputH;
real* outputForPlane = output + plane * outputW * outputH;
real* indicesForPlane = indices + plane * outputW * outputH;
for (h = 0; h < outputH; ++h) {
long inputHStart = sequenceH[h];
for (w = 0; w < outputW; ++w) {
long inputWStart = sequenceW[w];
real maxVal = -THInf;
long maxIndex = -1;
long h2, w2;
for (h2 = inputHStart; h2 < inputHStart + poolSizeH; ++h2) {
for (w2 = inputWStart; w2 < inputWStart + poolSizeW; ++w2) {
THAssert(h2 >= 0 && h2 < inputH);
THAssert(w2 >= 0 && w2 < inputW);
long planeIndex = h2 * inputW + w2;
real val = inputForPlane[planeIndex];
if (val > maxVal) {
maxVal = val;
maxIndex = planeIndex;
}
}
}
THAssert(maxVal != -THInf);
THAssert(maxIndex != -1);
outputForPlane[h * outputW + w] = maxVal;
/* +1 to lua index */
indicesForPlane[h * outputW + w] = (real) maxIndex + TH_INDEX_BASE;
}
}
THFree(sequenceW);
THFree(sequenceH);
}
}
