tiling_2d.c 6.58 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 >= 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 >= 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
	struct aml_tiling_iterator_2d_data *data =
132 133 134 135 136 137 138 139 140 141 142 143
		(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;
144

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
	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;
}

int aml_tiling_2d_destroy_iterator(struct aml_tiling_data *t,
				   struct aml_tiling_iterator *it)
{
	return 0;
}


163 164 165 166
struct aml_tiling_ops aml_tiling_2d_rowmajor_ops = {
	aml_tiling_2d_create_iterator,
	aml_tiling_2d_init_iterator,
	aml_tiling_2d_destroy_iterator,
167
	aml_tiling_2d_rowmajor_tileid,
168
	aml_tiling_2d_tilesize,
169
	aml_tiling_2d_tilestart,
170 171 172 173
	aml_tiling_2d_ndims,
};

struct aml_tiling_ops aml_tiling_2d_colmajor_ops = {
174 175 176
	aml_tiling_2d_create_iterator,
	aml_tiling_2d_init_iterator,
	aml_tiling_2d_destroy_iterator,
177
	aml_tiling_2d_colmajor_tileid,
178
	aml_tiling_2d_tilesize,
179
	aml_tiling_2d_tilestart,
180
	aml_tiling_2d_ndims,
181
};
182 183 184 185 186 187 188 189 190 191 192 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 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263

/*******************************************************************************
 * 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)
{
	int err;
	struct aml_tiling_2d_data *data;

	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 */
}


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