tiling_2d.c 6.83 KB
Newer Older
Swann Perarnau's avatar
Swann Perarnau committed
1 2 3 4 5 6 7 8 9 10
/*******************************************************************************
 * Copyright 2019 UChicago Argonne, LLC.
 * (c.f. AUTHORS, LICENSE)
 *
 * This file is part of the AML project.
 * For more info, see https://xgitlab.cels.anl.gov/argo/aml
 *
 * SPDX-License-Identifier: BSD-3-Clause
*******************************************************************************/

11
#include "aml.h"
12
#include "aml/tiling/2d.h"
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
#include <assert.h>

/*******************************************************************************
 * 2D Iterator
 ******************************************************************************/

int aml_tiling_iterator_2d_reset(struct aml_tiling_iterator_data *data)
{
	struct aml_tiling_iterator_2d_data *it =
		(struct aml_tiling_iterator_2d_data *)data;
	it->i = 0;
	return 0;
}

int aml_tiling_iterator_2d_end(const struct aml_tiling_iterator_data *data)
{
	const struct aml_tiling_iterator_2d_data *it =
		(const struct aml_tiling_iterator_2d_data *)data;
	return it->i * it->tiling->blocksize >= it->tiling->totalsize;
}

int aml_tiling_iterator_2d_next(struct aml_tiling_iterator_data *data)
{
	struct aml_tiling_iterator_2d_data *it =
		(struct aml_tiling_iterator_2d_data *)data;
	it->i++;
	return 0;
}

int aml_tiling_iterator_2d_get(const struct aml_tiling_iterator_data *data,
			       va_list args)
{
	const struct aml_tiling_iterator_2d_data *it =
		(const struct aml_tiling_iterator_2d_data *)data;
	unsigned long *x = va_arg(args, unsigned long *);
	*x = it->i;
	return 0;
}

struct aml_tiling_iterator_ops aml_tiling_iterator_2d_ops = {
	aml_tiling_iterator_2d_reset,
	aml_tiling_iterator_2d_next,
	aml_tiling_iterator_2d_end,
	aml_tiling_iterator_2d_get,
};

/*******************************************************************************
 * 2D ops
61
 * Tileids are the order in memory of the tiles.
62 63
 ******************************************************************************/

64
int aml_tiling_2d_rowmajor_tileid(const struct aml_tiling_data *t, va_list ap)
65 66 67
{
	const struct aml_tiling_2d_data *data =
		(const struct aml_tiling_2d_data *)t;
68 69
	size_t row = va_arg(ap, size_t);
	size_t col = va_arg(ap, size_t);
70 71

	if (row >= data->ndims[0] || col >= data->ndims[1])
72 73 74
		return -1;
	else
		return (row*data->ndims[1]) + col;
75 76
}

77
int aml_tiling_2d_colmajor_tileid(const struct aml_tiling_data *t, va_list ap)
78 79 80
{
	const struct aml_tiling_2d_data *data =
		(const struct aml_tiling_2d_data *)t;
81 82
	size_t row = va_arg(ap, size_t);
	size_t col = va_arg(ap, size_t);
83 84

	if (row >= data->ndims[0] || col >= data->ndims[1])
85
		return -1;
86
	else
87
		return (col*data->ndims[0]) + row;
88 89
}

90 91 92 93
size_t aml_tiling_2d_tilesize(const struct aml_tiling_data *t, int tileid)
{
	const struct aml_tiling_2d_data *data =
		(const struct aml_tiling_2d_data *)t;
94

95
	if (tileid < 0 || tileid >= (int)(data->ndims[0]*data->ndims[1]))
96 97 98 99 100
		return 0;
	else
		return data->blocksize;
}

101
void *aml_tiling_2d_tilestart(const struct aml_tiling_data *t,
102
			      const void *ptr, int tileid)
103 104 105 106
{
	const struct aml_tiling_2d_data *data =
		(const struct aml_tiling_2d_data *)t;
	intptr_t p = (intptr_t)ptr;
107

108
	if (tileid < 0 || tileid >= (int)(data->ndims[0]*data->ndims[1]))
109 110
		return NULL;
	else
111
		return (void *)(p + tileid*data->blocksize);
112 113 114 115 116 117
}

int aml_tiling_2d_ndims(const struct aml_tiling_data *t, va_list ap)
{
	const struct aml_tiling_2d_data *data =
		(const struct aml_tiling_2d_data *)t;
118 119
	size_t *nrows = va_arg(ap, size_t *);
	size_t *ncols = va_arg(ap, size_t *);
120

121
	/* looks totally wrong */
122 123
	*nrows = data->ndims[0];
	*ncols = data->ndims[1];
124 125 126 127 128 129 130
	return 0;
}

int aml_tiling_2d_init_iterator(struct aml_tiling_data *t,
				struct aml_tiling_iterator *it, int flags)
{
	assert(it->data != NULL);
131
	(void)flags;
132
	struct aml_tiling_iterator_2d_data *data =
133 134 135 136 137 138 139 140 141 142 143 144
		(struct aml_tiling_iterator_2d_data *)it->data;
	it->ops = &aml_tiling_iterator_2d_ops;
	data->i = 0;
	data->tiling = (struct aml_tiling_2d_data *)t;
	return 0;
}

int aml_tiling_2d_create_iterator(struct aml_tiling_data *t,
				  struct aml_tiling_iterator **it, int flags)
{
	intptr_t baseptr, dataptr;
	struct aml_tiling_iterator *ret;
145

146 147 148 149 150 151 152 153 154 155 156
	baseptr = (intptr_t) calloc(1, AML_TILING_ITERATOR_2D_ALLOCSIZE);
	dataptr = baseptr + sizeof(struct aml_tiling_iterator);

	ret = (struct aml_tiling_iterator *)baseptr;
	ret->data = (struct aml_tiling_iterator_data *)dataptr;

	aml_tiling_2d_init_iterator(t, ret, flags);
	*it = ret;
	return 0;
}

157 158
int aml_tiling_2d_fini_iterator(struct aml_tiling_data *t,
				struct aml_tiling_iterator *it)
159
{
160 161
	(void)t;
	(void)it;
162 163 164
	return 0;
}

165 166 167
int aml_tiling_2d_destroy_iterator(struct aml_tiling_data *t,
				   struct aml_tiling_iterator **it)
{
168
	(void)t;
169 170 171
	free(*it);
	return 0;
}
172

173 174 175
struct aml_tiling_ops aml_tiling_2d_rowmajor_ops = {
	aml_tiling_2d_create_iterator,
	aml_tiling_2d_init_iterator,
176
	aml_tiling_2d_fini_iterator,
177
	aml_tiling_2d_destroy_iterator,
178
	aml_tiling_2d_rowmajor_tileid,
179
	aml_tiling_2d_tilesize,
180
	aml_tiling_2d_tilestart,
181 182 183 184
	aml_tiling_2d_ndims,
};

struct aml_tiling_ops aml_tiling_2d_colmajor_ops = {
185 186
	aml_tiling_2d_create_iterator,
	aml_tiling_2d_init_iterator,
187
	aml_tiling_2d_fini_iterator,
188
	aml_tiling_2d_destroy_iterator,
189
	aml_tiling_2d_colmajor_tileid,
190
	aml_tiling_2d_tilesize,
191
	aml_tiling_2d_tilestart,
192
	aml_tiling_2d_ndims,
193
};
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245

/*******************************************************************************
 * 2d create/destroy
 ******************************************************************************/

int aml_tiling_2d_create(struct aml_tiling **t, int type,
			 size_t tilesize, size_t totalsize,
			 size_t rowsize, size_t colsize)
{
	struct aml_tiling *ret = NULL;
	intptr_t baseptr, dataptr;
	int err;

	if (t == NULL)
		return -AML_EINVAL;

	if (type != AML_TILING_TYPE_2D_ROWMAJOR &&
	    type != AML_TILING_TYPE_2D_COLMAJOR)
		return -AML_EINVAL;

	/* alloc */
	baseptr = (intptr_t) calloc(1, AML_TILING_2D_ALLOCSIZE);
	if (baseptr == 0) {
		*t = NULL;
		return -AML_ENOMEM;
	}
	dataptr = baseptr + sizeof(struct aml_tiling);

	ret = (struct aml_tiling *)baseptr;
	ret->data = (struct aml_tiling_data *)dataptr;
	if (type == AML_TILING_TYPE_2D_ROWMAJOR)
		ret->ops = &aml_tiling_2d_rowmajor_ops;
	else
		ret->ops = &aml_tiling_2d_colmajor_ops;

	err = aml_tiling_2d_init(ret, type, tilesize, totalsize,
				 rowsize, colsize);
	if (err) {
		free(ret);
		ret = NULL;
	}

	*t = ret;
	return err;
}


int aml_tiling_2d_init(struct aml_tiling *t, int type,
		       size_t tilesize, size_t totalsize,
		       size_t rowsize, size_t colsize)
{
	struct aml_tiling_2d_data *data;
246
	(void)type;
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264

	if (t == NULL || t->data == NULL)
		return -AML_EINVAL;
	data = (struct aml_tiling_2d_data *)t->data;

	if (tilesize > totalsize)
		return -AML_EINVAL;

	data->blocksize = tilesize;
	data->totalsize = totalsize;
	data->ndims[0] = rowsize;
	data->ndims[1] = colsize;
	return 0;
}

void aml_tiling_2d_fini(struct aml_tiling *t)
{
	/* nothing to do */
265
	(void)t;
266 267 268 269 270 271 272 273 274 275 276
}


void aml_tiling_2d_destroy(struct aml_tiling **t)
{
	if (t == NULL)
		return;
	free(*t);
	*t = NULL;
}