Skip to content
This repository was archived by the owner on Jan 26, 2022. It is now read-only.

Commit cb237c0

Browse files
vfdev-5vfdev-5
committed
Fix compiling errors for pytorch 0.4.1
1 parent dddeb6f commit cb237c0

File tree

4 files changed

+101
-102
lines changed

4 files changed

+101
-102
lines changed

‎lib/model/nms/src/nms_cuda.c

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -8,12 +8,12 @@ extern THCState *state;
88
int nms_cuda(THCudaIntTensor *keep_out, THCudaTensor *boxes_host,
99
THCudaIntTensor *num_out, float nms_overlap_thresh) {
1010

11-
nms_cuda_compute(THCudaIntTensor_data(state, keep_out),
12-
THCudaIntTensor_data(state, num_out),
13-
THCudaTensor_data(state, boxes_host),
14-
boxes_host->size[0],
15-
boxes_host->size[1],
16-
nms_overlap_thresh);
11+
nms_cuda_compute(THCudaIntTensor_data(state, keep_out),
12+
THCudaIntTensor_data(state, num_out),
13+
THCudaTensor_data(state, boxes_host),
14+
THCudaTensor_size(state, boxes_host, 0),
15+
THCudaTensor_size(state, boxes_host, 1),
16+
nms_overlap_thresh);
1717

1818
return 1;
1919
}

‎lib/model/roi_crop/make.sh

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,4 +7,4 @@ echo "Compiling my_lib kernels by nvcc..."
77
nvcc -c -o roi_crop_cuda_kernel.cu.o roi_crop_cuda_kernel.cu -x cu -Xcompiler -fPIC -arch=sm_52
88

99
cd ../
10-
python build.py
10+
python3 build.py

‎lib/model/roi_crop/src/roi_crop.c

Lines changed: 86 additions & 87 deletions
Original file line numberDiff line numberDiff line change
@@ -7,24 +7,24 @@
77
int BilinearSamplerBHWD_updateOutput(THFloatTensor *inputImages, THFloatTensor *grids, THFloatTensor *output)
88
{
99

10-
int batchsize = inputImages->size[0];
11-
int inputImages_height = inputImages->size[1];
12-
int inputImages_width = inputImages->size[2];
13-
int output_height = output->size[1];
14-
int output_width = output->size[2];
15-
int inputImages_channels = inputImages->size[3];
10+
int batchsize = THFloatTensor_size(inputImages, 0);
11+
int inputImages_height = THFloatTensor_size(inputImages, 1);
12+
int inputImages_width = THFloatTensor_size(inputImages, 2);
13+
int output_height = THFloatTensor_size(output, 1);
14+
int output_width = THFloatTensor_size(output, 2);
15+
int inputImages_channels = THFloatTensor_size(inputImages, 3);
1616

17-
int output_strideBatch = output->stride[0];
18-
int output_strideHeight = output->stride[1];
19-
int output_strideWidth = output->stride[2];
17+
int output_strideBatch = THFloatTensor_stride(output, 0);
18+
int output_strideHeight = THFloatTensor_stride(output, 1);
19+
int output_strideWidth = THFloatTensor_stride(output, 2);
2020

21-
int inputImages_strideBatch = inputImages->stride[0];
22-
int inputImages_strideHeight = inputImages->stride[1];
23-
int inputImages_strideWidth = inputImages->stride[2];
21+
int inputImages_strideBatch = THFloatTensor_stride(inputImages, 0);
22+
int inputImages_strideHeight = THFloatTensor_stride(inputImages, 1);
23+
int inputImages_strideWidth = THFloatTensor_stride(inputImages, 2);
2424

25-
int grids_strideBatch = grids->stride[0];
26-
int grids_strideHeight = grids->stride[1];
27-
int grids_strideWidth = grids->stride[2];
25+
int grids_strideBatch = THFloatTensor_stride(grids, 0);
26+
int grids_strideHeight = THFloatTensor_stride(grids, 1);
27+
int grids_strideWidth = THFloatTensor_stride(grids, 2);
2828

2929

3030
real *inputImages_data, *output_data, *grids_data;
@@ -107,32 +107,32 @@ int BilinearSamplerBHWD_updateGradInput(THFloatTensor *inputImages, THFloatTenso
107107
{
108108
bool onlyGrid=false;
109109

110-
int batchsize = inputImages->size[0];
111-
int inputImages_height = inputImages->size[1];
112-
int inputImages_width = inputImages->size[2];
113-
int gradOutput_height = gradOutput->size[1];
114-
int gradOutput_width = gradOutput->size[2];
115-
int inputImages_channels = inputImages->size[3];
110+
int batchsize = THFloatTensor_size(inputImages, 0);
111+
int inputImages_height = THFloatTensor_size(inputImages, 1);
112+
int inputImages_width = THFloatTensor_size(inputImages, 2);
113+
int gradOutput_height = THFloatTensor_size(gradOutput, 1);
114+
int gradOutput_width = THFloatTensor_size(gradOutput, 2);
115+
int inputImages_channels = THFloatTensor_size(inputImages, 3);
116116

117-
int gradOutput_strideBatch = gradOutput->stride[0];
118-
int gradOutput_strideHeight = gradOutput->stride[1];
119-
int gradOutput_strideWidth = gradOutput->stride[2];
117+
int inputImages_strideBatch = THFloatTensor_stride(inputImages, 0);
118+
int inputImages_strideHeight = THFloatTensor_stride(inputImages, 1);
119+
int inputImages_strideWidth = THFloatTensor_stride(inputImages, 2);
120120

121-
int inputImages_strideBatch = inputImages->stride[0];
122-
int inputImages_strideHeight = inputImages->stride[1];
123-
int inputImages_strideWidth = inputImages->stride[2];
121+
int gradOutput_strideBatch = THFloatTensor_stride(gradOutput, 0);
122+
int gradOutput_strideHeight = THFloatTensor_stride(gradOutput, 1);
123+
int gradOutput_strideWidth = THFloatTensor_stride(gradOutput, 2);
124124

125-
int gradInputImages_strideBatch = gradInputImages->stride[0];
126-
int gradInputImages_strideHeight = gradInputImages->stride[1];
127-
int gradInputImages_strideWidth = gradInputImages->stride[2];
125+
int gradInputImages_strideBatch = THFloatTensor_stride(gradInputImages, 0);
126+
int gradInputImages_strideHeight = THFloatTensor_stride(gradInputImages, 1);
127+
int gradInputImages_strideWidth = THFloatTensor_stride(gradInputImages, 2);
128128

129-
int grids_strideBatch = grids->stride[0];
130-
int grids_strideHeight = grids->stride[1];
131-
int grids_strideWidth = grids->stride[2];
129+
int grids_strideBatch = THFloatTensor_stride(grids, 0);
130+
int grids_strideHeight = THFloatTensor_stride(grids, 1);
131+
int grids_strideWidth = THFloatTensor_stride(grids, 2);
132132

133-
int gradGrids_strideBatch = gradGrids->stride[0];
134-
int gradGrids_strideHeight = gradGrids->stride[1];
135-
int gradGrids_strideWidth = gradGrids->stride[2];
133+
int gradGrids_strideBatch = THFloatTensor_stride(gradGrids, 0);
134+
int gradGrids_strideHeight = THFloatTensor_stride(gradGrids, 1);
135+
int gradGrids_strideWidth = THFloatTensor_stride(gradGrids, 2);
136136

137137
real *inputImages_data, *gradOutput_data, *grids_data, *gradGrids_data, *gradInputImages_data;
138138
inputImages_data = THFloatTensor_data(inputImages);
@@ -246,29 +246,29 @@ int BilinearSamplerBHWD_updateGradInput(THFloatTensor *inputImages, THFloatTenso
246246
int BilinearSamplerBCHW_updateOutput(THFloatTensor *inputImages, THFloatTensor *grids, THFloatTensor *output)
247247
{
248248

249-
int batchsize = inputImages->size[0];
250-
int inputImages_height = inputImages->size[2];
251-
int inputImages_width = inputImages->size[3];
249+
int batchsize = THFloatTensor_size(inputImages, 0);
250+
int inputImages_height = THFloatTensor_size(inputImages, 2);
251+
int inputImages_width = THFloatTensor_size(inputImages, 3);
252252

253-
int output_height = output->size[2];
254-
int output_width = output->size[3];
255-
int inputImages_channels = inputImages->size[1];
256-
257-
int output_strideBatch = output->stride[0];
258-
int output_strideHeight = output->stride[2];
259-
int output_strideWidth = output->stride[3];
260-
int output_strideChannel = output->stride[1];
253+
int output_height = THFloatTensor_size(output, 2);
254+
int output_width = THFloatTensor_size(output, 3);
255+
int inputImages_channels = THFloatTensor_size(inputImages, 1);
256+
257+
int output_strideBatch = THFloatTensor_stride(output, 0);
258+
int output_strideHeight = THFloatTensor_stride(output, 2);
259+
int output_strideWidth = THFloatTensor_stride(output, 3);
260+
int output_strideChannel = THFloatTensor_stride(output, 1);
261261

262262

263-
int inputImages_strideBatch = inputImages->stride[0];
264-
int inputImages_strideHeight = inputImages->stride[2];
265-
int inputImages_strideWidth = inputImages->stride[3];
266-
int inputImages_strideChannel = inputImages->stride[1];
263+
int inputImages_strideBatch = THFloatTensor_stride(inputImages, 0);
264+
int inputImages_strideHeight = THFloatTensor_stride(inputImages, 2);
265+
int inputImages_strideWidth = THFloatTensor_stride(inputImages, 3);
266+
int inputImages_strideChannel = THFloatTensor_stride(inputImages, 1);
267267

268-
int grids_strideBatch = grids->stride[0];
269-
int grids_strideHeight = grids->stride[2];
270-
int grids_strideWidth = grids->stride[3];
271-
int grids_strideChannel = grids->stride[1];
268+
int grids_strideBatch = THFloatTensor_stride(grids, 0);
269+
int grids_strideHeight = THFloatTensor_stride(grids, 2);
270+
int grids_strideWidth = THFloatTensor_stride(grids, 3);
271+
int grids_strideChannel = THFloatTensor_stride(grids, 1);
272272

273273

274274
real *inputImages_data, *output_data, *grids_data;
@@ -352,38 +352,37 @@ int BilinearSamplerBCHW_updateGradInput(THFloatTensor *inputImages, THFloatTenso
352352
{
353353
bool onlyGrid=false;
354354

355-
int batchsize = inputImages->size[0];
356-
int inputImages_height = inputImages->size[2];
357-
int inputImages_width = inputImages->size[3];
358-
int gradOutput_height = gradOutput->size[2];
359-
int gradOutput_width = gradOutput->size[3];
360-
int inputImages_channels = inputImages->size[1];
361-
362-
int gradOutput_strideBatch = gradOutput->stride[0];
363-
int gradOutput_strideHeight = gradOutput->stride[2];
364-
int gradOutput_strideWidth = gradOutput->stride[3];
365-
int gradOutput_strideChannel = gradOutput->stride[1];
366-
367-
int inputImages_strideBatch = inputImages->stride[0];
368-
int inputImages_strideHeight = inputImages->stride[2];
369-
int inputImages_strideWidth = inputImages->stride[3];
370-
int inputImages_strideChannel = inputImages->stride[1];
371-
372-
373-
int gradInputImages_strideBatch = gradInputImages->stride[0];
374-
int gradInputImages_strideHeight = gradInputImages->stride[2];
375-
int gradInputImages_strideWidth = gradInputImages->stride[3];
376-
int gradInputImages_strideChannel = gradInputImages->stride[1];
377-
378-
int grids_strideBatch = grids->stride[0];
379-
int grids_strideHeight = grids->stride[2];
380-
int grids_strideWidth = grids->stride[3];
381-
int grids_strideChannel = grids->stride[1];
382-
383-
int gradGrids_strideBatch = gradGrids->stride[0];
384-
int gradGrids_strideHeight = gradGrids->stride[2];
385-
int gradGrids_strideWidth = gradGrids->stride[3];
386-
int gradGrids_strideChannel = gradGrids->stride[1];
355+
int batchsize = THFloatTensor_size(inputImages, 0);
356+
int inputImages_height = THFloatTensor_size(inputImages, 2);
357+
int inputImages_width = THFloatTensor_size(inputImages, 3);
358+
int inputImages_channels = THFloatTensor_size(inputImages, 1);
359+
int gradOutput_height = THFloatTensor_size(gradOutput, 2);
360+
int gradOutput_width = THFloatTensor_size(gradOutput, 3);
361+
362+
int gradOutput_strideBatch = THFloatTensor_stride(gradOutput, 0);
363+
int gradOutput_strideHeight = THFloatTensor_stride(gradOutput, 2);
364+
int gradOutput_strideWidth = THFloatTensor_stride(gradOutput, 3);
365+
int gradOutput_strideChannel = THFloatTensor_stride(gradOutput, 1);
366+
367+
int inputImages_strideBatch = THFloatTensor_stride(inputImages, 0);
368+
int inputImages_strideHeight = THFloatTensor_stride(inputImages, 2);
369+
int inputImages_strideWidth = THFloatTensor_stride(inputImages, 3);
370+
int inputImages_strideChannel = THFloatTensor_stride(inputImages, 1);
371+
372+
int gradInputImages_strideBatch = THFloatTensor_stride(gradInputImages, 0);
373+
int gradInputImages_strideHeight = THFloatTensor_stride(gradInputImages, 2);
374+
int gradInputImages_strideWidth = THFloatTensor_stride(gradInputImages, 3);
375+
int gradInputImages_strideChannel = THFloatTensor_stride(gradInputImages, 1);
376+
377+
int grids_strideBatch = THFloatTensor_stride(grids, 0);
378+
int grids_strideHeight = THFloatTensor_stride(grids, 2);
379+
int grids_strideWidth = THFloatTensor_stride(grids, 3);
380+
int grids_strideChannel = THFloatTensor_stride(grids, 1);
381+
382+
int gradGrids_strideBatch = THFloatTensor_stride(gradGrids, 0);
383+
int gradGrids_strideHeight = THFloatTensor_stride(gradGrids, 2);
384+
int gradGrids_strideWidth = THFloatTensor_stride(gradGrids, 3);
385+
int gradGrids_strideChannel = THFloatTensor_stride(gradGrids, 1);
387386

388387
real *inputImages_data, *gradOutput_data, *grids_data, *gradGrids_data, *gradInputImages_data;
389388
inputImages_data = THFloatTensor_data(inputImages);

‎lib/model/roi_crop/src/roi_crop_cuda.c

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -19,10 +19,10 @@ int BilinearSamplerBHWD_updateOutput_cuda(THCudaTensor *inputImages, THCudaTenso
1919
// THCudaTensor *output = (THCudaTensor *)luaT_checkudata(L, 4, "torch.CudaTensor");
2020

2121
int success = 0;
22-
success = BilinearSamplerBHWD_updateOutput_cuda_kernel(output->size[1],
23-
output->size[3],
24-
output->size[2],
25-
output->size[0],
22+
success = BilinearSamplerBHWD_updateOutput_cuda_kernel(THCudaTensor_size(state, output, 1),
23+
THCudaTensor_size(state, output, 3),
24+
THCudaTensor_size(state, output, 2),
25+
THCudaTensor_size(state, output, 0),
2626
THCudaTensor_size(state, inputImages, 1),
2727
THCudaTensor_size(state, inputImages, 2),
2828
THCudaTensor_size(state, inputImages, 3),
@@ -62,10 +62,10 @@ int BilinearSamplerBHWD_updateGradInput_cuda(THCudaTensor *inputImages, THCudaTe
6262
// THCudaTensor *gradOutput = (THCudaTensor *)luaT_checkudata(L, 6, "torch.CudaTensor");
6363

6464
int success = 0;
65-
success = BilinearSamplerBHWD_updateGradInput_cuda_kernel(gradOutput->size[1],
66-
gradOutput->size[3],
67-
gradOutput->size[2],
68-
gradOutput->size[0],
65+
success = BilinearSamplerBHWD_updateGradInput_cuda_kernel(THCudaTensor_size(state, gradOutput, 1),
66+
THCudaTensor_size(state, gradOutput, 3),
67+
THCudaTensor_size(state, gradOutput, 2),
68+
THCudaTensor_size(state, gradOutput, 0),
6969
THCudaTensor_size(state, inputImages, 1),
7070
THCudaTensor_size(state, inputImages, 2),
7171
THCudaTensor_size(state, inputImages, 3),

0 commit comments

Comments
 (0)