tiling_1d.c 5.29 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/1d.h"
13 14 15 16 17 18 19 20 21 22 23 24 25 26
#include <assert.h>

/*******************************************************************************
 * 1D Iterator
 ******************************************************************************/

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

Kamil Iskra's avatar
Kamil Iskra committed
27
int aml_tiling_iterator_1d_end(const struct aml_tiling_iterator_data *data)
28
{
Kamil Iskra's avatar
Kamil Iskra committed
29 30
	const struct aml_tiling_iterator_1d_data *it =
		(const struct aml_tiling_iterator_1d_data *)data;
31 32 33 34 35 36 37 38 39 40 41
	return it->i * it->tiling->blocksize >= it->tiling->totalsize;
}

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

Kamil Iskra's avatar
Kamil Iskra committed
42
int aml_tiling_iterator_1d_get(const struct aml_tiling_iterator_data *data,
43 44
			       va_list args)
{
Kamil Iskra's avatar
Kamil Iskra committed
45 46
	const struct aml_tiling_iterator_1d_data *it =
		(const struct aml_tiling_iterator_1d_data *)data;
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
	unsigned long *x = va_arg(args, unsigned long *);
	*x = it->i;
	return 0;
}

struct aml_tiling_iterator_ops aml_tiling_iterator_1d_ops = {
	aml_tiling_iterator_1d_reset,
	aml_tiling_iterator_1d_next,
	aml_tiling_iterator_1d_end,
	aml_tiling_iterator_1d_get,
};

/*******************************************************************************
 * 1D ops
 ******************************************************************************/

63 64 65 66 67 68 69 70
int aml_tiling_1d_tileid(const struct aml_tiling_data *t, va_list ap)
{
	const struct aml_tiling_1d_data *data =
		(const struct aml_tiling_1d_data *)t;
	size_t x = va_arg(ap, size_t);
	return x;
}

Kamil Iskra's avatar
Kamil Iskra committed
71
size_t aml_tiling_1d_tilesize(const struct aml_tiling_data *t, int tileid)
72
{
Kamil Iskra's avatar
Kamil Iskra committed
73 74
	const struct aml_tiling_1d_data *data =
		(const struct aml_tiling_1d_data *)t;
75 76

	if (tileid < 0)
77 78 79
		return 0;
	else
		return data->blocksize;
80 81
}

82 83
void *aml_tiling_1d_tilestart(const struct aml_tiling_data *t,
			      const void *ptr, int tileid)
84
{
Kamil Iskra's avatar
Kamil Iskra committed
85 86
	const struct aml_tiling_1d_data *data =
		(const struct aml_tiling_1d_data *)t;
87
	intptr_t p = (intptr_t)ptr;
88 89

	if (tileid < 0)
90 91 92
		return NULL;
	else
		return (void *)(p + tileid*data->blocksize);
93 94
}

95 96 97 98 99 100
int aml_tiling_1d_ndims(const struct aml_tiling_data *t, va_list ap)
{
	const struct aml_tiling_1d_data *data =
		(const struct aml_tiling_1d_data *)t;
	size_t *x = va_arg(ap, size_t *);
	*x = data->totalsize/data->blocksize;
101
	if (data->totalsize % data->blocksize != 0)
102 103 104 105
		*x++;
	return 0;
}

106 107 108 109
int aml_tiling_1d_init_iterator(struct aml_tiling_data *t,
				struct aml_tiling_iterator *it, int flags)
{
	assert(it->data != NULL);
110
	struct aml_tiling_iterator_1d_data *data =
111
		(struct aml_tiling_iterator_1d_data *)it->data;
112

113 114 115 116 117 118 119 120 121 122 123
	it->ops = &aml_tiling_iterator_1d_ops;
	data->i = 0;
	data->tiling = (struct aml_tiling_1d_data *)t;
	return 0;
}

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

125 126
	baseptr = (intptr_t) calloc(1, AML_TILING_ITERATOR_1D_ALLOCSIZE);
	dataptr = baseptr + sizeof(struct aml_tiling_iterator);
127

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
	ret = (struct aml_tiling_iterator *)baseptr;
	ret->data = (struct aml_tiling_iterator_data *)dataptr;

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

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

struct aml_tiling_ops aml_tiling_1d_ops = {
	aml_tiling_1d_create_iterator,
	aml_tiling_1d_init_iterator,
	aml_tiling_1d_destroy_iterator,
146
	aml_tiling_1d_tileid,
147 148
	aml_tiling_1d_tilesize,
	aml_tiling_1d_tilestart,
149
	aml_tiling_1d_ndims,
150
};
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 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

/*******************************************************************************
 * 1D create/destroy
 ******************************************************************************/

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

	if (t == NULL)
		return -AML_EINVAL;

	/* alloc */
	baseptr = (intptr_t) calloc(1, AML_TILING_1D_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;
	ret->ops = &aml_tiling_1d_ops;

	err = aml_tiling_1d_init(ret, tilesize, totalsize);
	if (err) {
		free(ret);
		ret = NULL;
	}

	*t = ret;
	return err;
}


int aml_tiling_1d_init(struct aml_tiling *t,
		       size_t tilesize, size_t totalsize)
{
	int err;
	struct aml_tiling_1d_data *data;

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

	if (tilesize > totalsize)
		return -AML_EINVAL;

	data->blocksize = tilesize;
	data->totalsize = totalsize;
	return 0;
}

void aml_tiling_1d_fini(struct aml_tiling *t)
{
	/* nothing to do */
}


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