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); } }