source/union_domain.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include "../include/cloog/cloog.h"
   5
   6 #define ALLOC(type) (type*)malloc(sizeof(type))
   7 #define ALLOCN(type,n) (type*)malloc((n)*sizeof(type))
   8
   9 void cloog_named_domain_list_free(CloogNamedDomainList *list)
  10 {
  11         while (list != NULL) {
  12                 CloogNamedDomainList *temp = list->next;
  13                 cloog_domain_free(list->domain);
  14                 cloog_scattering_free(list->scattering);
  15                 free(list->name);
  16                 free(list);
  17                 list = temp;
  18         }
  19 }
  20
  21 CloogUnionDomain *cloog_union_domain_alloc(int nb_par)
  22 {
  23         CloogUnionDomain *ud;
  24
  25         ud = ALLOC(CloogUnionDomain);
  26         if (!ud)
  27                 cloog_die("memory overflow.\n");
  28
  29         ud->domain = NULL;
  30         ud->next_domain = &ud->domain;
  31
  32         ud->n_name[CLOOG_PARAM] = nb_par;
  33         ud->n_name[CLOOG_ITER] = 0;
  34         ud->n_name[CLOOG_SCAT] = 0;
  35
  36         ud->name[CLOOG_PARAM] = NULL;
  37         ud->name[CLOOG_ITER] = NULL;
  38         ud->name[CLOOG_SCAT] = NULL;
  39
  40         return ud;
  41 }
  42
  43 void cloog_union_domain_free(CloogUnionDomain *ud)
  44 {
  45         int i;
  46         int j;
  47
  48         if (!ud)
  49                 return;
  50
  51         for (i = 0; i < 3; ++i) {
  52                 if (!ud->name[i])
  53                         continue;
  54                 for (j = 0; j < ud->n_name[i]; ++i)
  55                         free(ud->name[i][j]);
  56                 free(ud->name[i]);
  57         }
  58
  59         cloog_named_domain_list_free(ud->domain);
  60
  61         free(ud);
  62 }
  63
  64 /**
  65  * Add a domain with scattering function to the union of domains.
  66  * name may be NULL and is duplicated if it is not.
  67  * domain and scattering are taken over by the CloogUnionDomain.
  68  * scattering may be NULL.
  69  */
  70 CloogUnionDomain *cloog_union_domain_add_domain(CloogUnionDomain *ud,
  71         const char *name, CloogDomain *domain, CloogScattering *scattering,
  72         void *usr)
  73 {
  74         CloogNamedDomainList *named;
  75         int n;
  76
  77         if (!ud)
  78                 return NULL;
  79
  80         named = ALLOC(CloogNamedDomainList);
  81         if (!named)
  82                 cloog_die("memory overflow.\n");
  83
  84         if (ud->name[CLOOG_ITER])
  85                 cloog_die("iterator names must be set after adding domains.\n");
  86         if (ud->name[CLOOG_SCAT])
  87                 cloog_die("scattering names must be set after adding domains.\n");
  88
  89         n = cloog_domain_dimension(domain);
  90         if (n > ud->n_name[CLOOG_ITER])
  91                 ud->n_name[CLOOG_ITER] = n;
  92
  93         if (scattering) {
  94                 n = cloog_scattering_dimension(scattering, domain);
  95                 if (n > ud->n_name[CLOOG_SCAT])
  96                         ud->n_name[CLOOG_SCAT] = n;
  97         }
  98
  99         named->domain = domain;
 100         named->scattering = scattering;
 101         named->name = name ? strdup(name) : NULL;
 102         named->usr = usr;
 103         named->next = NULL;
 104
 105         *ud->next_domain = named;
 106         ud->next_domain = &named->next;
 107
 108         return ud;
 109 }
 110
 111 /**
 112  * Set the name of parameter, iterator or scattering dimension
 113  * at the specified position.  The name is duplicated.
 114  */
 115 CloogUnionDomain *cloog_union_domain_set_name(CloogUnionDomain *ud,
 116         enum cloog_dim_type type, int index, const char *name)
 117 {
 118         int i;
 119
 120         if (!ud)
 121                 return ud;
 122
 123         if (type != CLOOG_PARAM &&
 124             type != CLOOG_ITER &&
 125             type != CLOOG_SCAT)
 126                 cloog_die("invalid dim type\n");
 127
 128         if (index < 0 || index >= ud->n_name[type])
 129                 cloog_die("index out of range\n");
 130
 131         if (!ud->name[type]) {
 132                 ud->name[type] = ALLOCN(char *, ud->n_name[type]);
 133                 if (!ud->name[type])
 134                         cloog_die("memory overflow.\n");
 135                 for (i = 0; i < ud->n_name[type]; ++i)
 136                         ud->name[type][i] = NULL;
 137         }
 138
 139         ud->name[type][index] = strdup(name);
 140         if (!ud->name[type][index])
 141                 cloog_die("memory overflow.\n");
 142
 143         return ud;
 144 }
 145
 146 static char *next_line(FILE *input, char *line, unsigned len)
 147 {
 148         char *p;
 149
 150         do {
 151                 if (!(p = fgets(line, len, input)))
 152                         return NULL;
 153                 while (isspace(*p) && *p != '\n')
 154                         ++p;
 155         } while (*p == '#' || *p == '\n');
 156
 157         return p;
 158 }
 159
 160 /**
 161  * cloog_scattering_list_read
 162  * Read in a list of scattering functions for the nb_statements
 163  * domains in loop.
 164  */
 165 static CloogScatteringList *cloog_scattering_list_read(FILE * foo,
 166         CloogDomain **domain, int nb_statements, int nb_parameters)
 167 {
 168     int nb_scat = 0;
 169     char s[MAX_STRING];
 170     CloogScatteringList *list = NULL, **next = &list;
 171
 172     /* We read first the number of scattering functions in the list. */
 173     do {
 174         if (!fgets(s, MAX_STRING, foo))
 175             break;
 176     } while ((*s=='#' || *s=='\n') || (sscanf(s, " %d", &nb_scat) < 1));
 177
 178     if (nb_scat == 0)
 179         return NULL;
 180
 181     if (nb_scat != nb_statements)
 182         cloog_die("wrong number of scattering functions.\n");
 183
 184     while (nb_scat--) {
 185         *next = (CloogScatteringList *)malloc(sizeof(CloogScatteringList));
 186         (*next)->scatt = cloog_domain_read_scattering(*domain, foo);
 187         (*next)->next = NULL;
 188
 189         next = &(*next)->next;
 190         domain++;
 191     }
 192     return list;
 193 }
 194
 195 static CloogUnionDomain *set_names_from_list(CloogUnionDomain *ud,
 196         enum cloog_dim_type type, int n, char **names)
 197 {
 198         int i;
 199
 200         if (!names)
 201                 return ud;
 202
 203         for (i = 0; i < n; ++i) {
 204                 ud = cloog_union_domain_set_name(ud, type, i, names[i]);
 205                 free(names[i]);
 206         }
 207         free(names);
 208
 209         return ud;
 210 }
 211
 212 /**
 213  * Fill up a CloogUnionDomain from information in a CLooG input file.
 214  * The language and the context are assumed to have been read from
 215  * the input file already.
 216  */
 217 CloogUnionDomain *cloog_union_domain_read(FILE *file, int nb_par,
 218         CloogOptions *options)
 219 {
 220         int op1, op2, op3;
 221         char line[MAX_STRING];
 222         CloogDomain **domain;
 223         CloogUnionDomain *ud;
 224         CloogScatteringList *scatteringl;
 225         int i;
 226         int n_iter = -1;
 227         int n_dom;
 228         char **names;
 229
 230         ud = cloog_union_domain_alloc(nb_par);
 231
 232         names = cloog_names_read_strings(file, nb_par);
 233         ud = set_names_from_list(ud, CLOOG_PARAM, nb_par, names);
 234
 235         /* We read the number of statements. */
 236         if (!next_line(file, line, sizeof(line)))
 237                 cloog_die("Input error.\n");
 238         if (sscanf(line, "%d", &n_dom) != 1)
 239                 cloog_die("Input error.\n");
 240
 241         domain = ALLOCN(CloogDomain *, n_dom);
 242         if (!domain)
 243                 cloog_die("memory overflow.\n");
 244
 245         for (i = 0; i < n_dom; ++i) {
 246                 int dim;
 247
 248                 domain[i] = cloog_domain_union_read(options->state, file,
 249                                                     nb_par);
 250                 dim = cloog_domain_dimension(domain[i]);
 251                 if (dim > n_iter)
 252                         n_iter = dim;
 253
 254                 /* To read that stupid "0 0 0" line. */
 255                 if (!next_line(file, line, sizeof(line)))
 256                         cloog_die("Input error.\n");
 257                 if (sscanf(line, " %d %d %d", &op1, &op2, &op3) != 3)
 258                         cloog_die("Input error.\n");
 259         }
 260
 261         /* Reading of the iterator names. */
 262         names = cloog_names_read_strings(file, n_iter);
 263
 264         /* Reading and putting the scattering data in program structure. */
 265         scatteringl = cloog_scattering_list_read(file, domain, n_dom, nb_par);
 266
 267         if (scatteringl) {
 268                 CloogScatteringList *is, *next;
 269
 270                 if (cloog_scattering_list_lazy_same(scatteringl))
 271                         cloog_msg(options, CLOOG_WARNING,
 272                                   "some scattering functions are similar.\n");
 273
 274                 for (i = 0, is = scatteringl; i < n_dom; ++i, is = next) {
 275                         next = is->next;
 276                         ud = cloog_union_domain_add_domain(ud, NULL, domain[i],
 277                                                               is->scatt, NULL);
 278                         free(is);
 279                 }
 280         } else {
 281                 for (i = 0; i < n_dom; ++i)
 282                         ud = cloog_union_domain_add_domain(ud, NULL, domain[i],
 283                                                                 NULL, NULL);
 284         }
 285
 286         ud = set_names_from_list(ud, CLOOG_ITER, n_iter, names);
 287
 288         if (scatteringl) {
 289                 int n_scat = ud->n_name[CLOOG_SCAT];
 290                 names = cloog_names_read_strings(file, n_scat);
 291                 ud = set_names_from_list(ud, CLOOG_SCAT, n_scat, names);
 292         }
 293
 294         free(domain);
 295
 296         return ud;
 297 }