Type renaming:

s/\bstarpu_htbl32_node_s\b/starpu_htbl32_node/g
s/\bstarpu_history_list_t\b/starpu_history_list/g
s/\bstarpu_buffer_descr_t\b/starpu_buffer_descr/g
s/\bstarpu_history_entry_t\b/starpu_history_entry/g
s/\bstarpu_history_list_t\b/starpu_history_list/g
s/\bstarpu_model_list_t\b/starpu_model_list/g
s/\bstarpu_regression_model_t\b/starpu_regression_model/g
s/\bstarpu_per_arch_perfmodel_t\b/starpu_per_arch_perfmodel/g

doc/chapters/basic-api.texi

@@ -1101,9 +1101,9 @@ implementations. When set to @code{NULL}, no code is executed during the tasks,
 such empty tasks can be useful for synchronization purposes.
 
 @item @code{buffers}
-Is an array of @code{starpu_buffer_descr_t} structures. It describes the
+Is an array of @code{struct starpu_buffer_descr} structures. It describes the
 different pieces of data accessed by the task, and how they should be accessed.
-The @code{starpu_buffer_descr_t} structure is composed of two fields, the
+The @code{struct starpu_buffer_descr} structure is composed of two fields, the
 @code{handle} field specifies the handle of the piece of data, and the
 @code{mode} field is the required access mode (eg @code{STARPU_RW}). The number
 of entries in this array must be specified in the @code{nbuffers} field of the

include/starpu_perfmodel.h

@@ -33,9 +33,9 @@
 extern "C" {
 #endif
 
-struct starpu_htbl32_node_s;
-struct starpu_history_list_t;
-struct starpu_buffer_descr_t;
+struct starpu_htbl32_node;
+struct starpu_history_list;
+struct starpu_buffer_descr;
 
 /* 
    it is possible that we have multiple versions of the same kind of workers,
@@ -54,7 +54,7 @@ enum starpu_perf_archtype {
 
 #define STARPU_NARCH_VARIATIONS	(STARPU_GORDON_DEFAULT+1)
 
-struct starpu_history_entry_t {
+struct starpu_history_entry {
 	//double measured;
 	
 	/* mean_n = 1/n sum */
@@ -89,17 +89,17 @@ struct starpu_history_entry_t {
 #endif
 };
 
-struct starpu_history_list_t {
-	struct starpu_history_list_t *next;
-	struct starpu_history_entry_t *entry;
+struct starpu_history_list {
+	struct starpu_history_list *next;
+	struct starpu_history_entry *entry;
 };
 
-struct starpu_model_list_t {
-	struct starpu_model_list_t *next;
+struct starpu_model_list {
+	struct starpu_model_list *next;
 	struct starpu_perfmodel *model;
 };
 
-struct starpu_regression_model_t {
+struct starpu_regression_model {
 	/* sum of ln(measured) */
 	double sumlny;
 
@@ -126,14 +126,14 @@ struct starpu_regression_model_t {
 	unsigned nsample;
 };
 
-struct starpu_per_arch_perfmodel_t {
-	double (*cost_model)(struct starpu_buffer_descr_t *t); /* returns expected duration in µs */
+struct starpu_per_arch_perfmodel {
+	double (*cost_model)(struct starpu_buffer_descr *t); /* returns expected duration in µs */
 
 	/* internal variables */
 	double alpha;
-	struct starpu_htbl32_node_s *history;
-	struct starpu_history_list_t *list;
-	struct starpu_regression_model_t regression;
+	struct starpu_htbl32_node *history;
+	struct starpu_history_list *list;
+	struct starpu_regression_model regression;
 #ifdef STARPU_MODEL_DEBUG
 	FILE *debug_file;
 #endif
@@ -152,10 +152,10 @@ struct starpu_perfmodel {
 	enum starpu_perfmodel_type type;
 
 	/* single cost model (STARPU_COMMON), returns expected duration in µs */
-	double (*cost_model)(struct starpu_buffer_descr_t *);
+	double (*cost_model)(struct starpu_buffer_descr *);
 
 	/* per-architecture model */
-	struct starpu_per_arch_perfmodel_t per_arch[STARPU_NARCH_VARIATIONS][STARPU_MAXIMPLEMENTATIONS];
+	struct starpu_per_arch_perfmodel per_arch[STARPU_NARCH_VARIATIONS][STARPU_MAXIMPLEMENTATIONS];
 
 	/* Name of the performance model, this is used as a file name when saving history-based performance models */
 	const char *symbol;

include/starpu_task.h

@@ -113,7 +113,7 @@ struct starpu_task {
 	struct starpu_codelet_t *cl;
 
 	/* arguments managed by the DSM */
-	struct starpu_buffer_descr_t buffers[STARPU_NMAXBUFS];
+	struct starpu_buffer_descr buffers[STARPU_NMAXBUFS];
 	void *interfaces[STARPU_NMAXBUFS];
 
 	/* arguments not managed by the DSM are given as a buffer */

mpi/starpu_mpi_insert_task.c

@@ -34,17 +34,17 @@
 #define MPI_CACHE
 
 #ifdef MPI_CACHE
-static struct starpu_htbl32_node_s **sent_data = NULL;
-static struct starpu_htbl32_node_s **received_data = NULL;
+static struct starpu_htbl32_node **sent_data = NULL;
+static struct starpu_htbl32_node **received_data = NULL;
 
 static void _starpu_mpi_task_init(int nb_nodes)
 {
         int i;
 
         _STARPU_MPI_DEBUG("Initialising hash table for cache\n");
-        sent_data = malloc(nb_nodes * sizeof(struct starpu_htbl32_node_s *));
+        sent_data = malloc(nb_nodes * sizeof(struct starpu_htbl32_node *));
         for(i=0 ; i<nb_nodes ; i++) sent_data[i] = NULL;
-        received_data = malloc(nb_nodes * sizeof(struct starpu_htbl32_node_s *));
+        received_data = malloc(nb_nodes * sizeof(struct starpu_htbl32_node *));
         for(i=0 ; i<nb_nodes ; i++) received_data[i] = NULL;
 }
 

src/common/htable32.c

@@ -21,7 +21,7 @@
 #include <stdint.h>
 #include <string.h>
 
-void *_starpu_htbl_search_32(struct starpu_htbl32_node_s *htbl, uint32_t key)
+void *_starpu_htbl_search_32(struct starpu_htbl32_node *htbl, uint32_t key)
 {
 	unsigned currentbit;
 	unsigned keysize = 32;
@@ -60,7 +60,7 @@ void *_starpu_htbl_search_32(struct starpu_htbl32_node_s *htbl, uint32_t key)
  * returns the previous value of the tag, or NULL else
  */
 
-void *_starpu_htbl_insert_32(struct starpu_htbl32_node_s **htbl, uint32_t key, void *entry)
+void *_starpu_htbl_insert_32(struct starpu_htbl32_node **htbl, uint32_t key, void *entry)
 {
 	unsigned currentbit;
 	unsigned keysize = 32;

src/common/htable32.h

@@ -26,18 +26,18 @@
 #define STARPU_HTBL32_NODE_SIZE	16
 
 /* Hierarchical table: all nodes have a 2^16 arity . */
-typedef struct starpu_htbl32_node_s {
+typedef struct starpu_htbl32_node {
 	unsigned nentries;
-	struct starpu_htbl32_node_s *children[1<<STARPU_HTBL32_NODE_SIZE];
+	struct starpu_htbl32_node *children[1<<STARPU_HTBL32_NODE_SIZE];
 } starpu_htbl32_node_t;
 
 /* Look for a 32bit key into the hierchical table. Returns the entry if
  * something is found, NULL otherwise. */
-void *_starpu_htbl_search_32(struct starpu_htbl32_node_s *htbl, uint32_t key);
+void *_starpu_htbl_search_32(struct starpu_htbl32_node *htbl, uint32_t key);
 
 /* Insert an entry indexed by the 32bit key into the hierarchical table.
  * Returns the entry that was previously associated to that key if any, NULL
  * otherwise. */
-void *_starpu_htbl_insert_32(struct starpu_htbl32_node_s **htbl, uint32_t key, void *entry);
+void *_starpu_htbl_insert_32(struct starpu_htbl32_node **htbl, uint32_t key, void *entry);
 
 #endif // __GENERIC_HTABLE_H__

src/core/jobs.h

@@ -71,8 +71,8 @@ LIST_TYPE(starpu_job,
 	/* To avoid deadlocks, we reorder the different buffers accessed to by
 	 * the task so that we always grab the rw-lock associated to the
 	 * handles in the same order. */
-	struct starpu_buffer_descr_t ordered_buffers[STARPU_NMAXBUFS];
-	
+	struct starpu_buffer_descr ordered_buffers[STARPU_NMAXBUFS];
+
 	/* If a tag is associated to the job, this points to the internal data
 	 * structure that describes the tag status. */
 	struct starpu_tag_s *tag;

src/core/perfmodel/perfmodel.c

@@ -71,7 +71,7 @@ enum starpu_perf_archtype starpu_worker_get_perf_archtype(int workerid)
 static double per_arch_task_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_task *task, unsigned nimpl)
 {
 	double exp = -1.0;
-	double (*per_arch_cost_model)(struct starpu_buffer_descr_t *);
+	double (*per_arch_cost_model)(struct starpu_buffer_descr *);
 	
 	per_arch_cost_model = model->per_arch[arch][nimpl].cost_model;
 

src/core/perfmodel/perfmodel.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009, 2010, 2011  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  * Copyright (C) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -28,7 +28,7 @@
 #include <pthread.h>
 #include <stdio.h>
 
-struct starpu_buffer_descr_t;
+struct starpu_buffer_descr;
 struct starpu_jobq_s;
 struct starpu_job_s;
 enum starpu_perf_archtype;
@@ -38,7 +38,7 @@ enum starpu_perf_archtype;
 //	unsigned ncore_entries;
 //	unsigned ncuda_entries;
 //	/* contains core entries, then cuda ones */
-//	struct starpu_history_entry_t entries[];
+//	struct starpu_history_entry entries[];
 //}
 
 void _starpu_get_perf_model_dir(char *path, size_t maxlen);

src/core/perfmodel/perfmodel_history.c

@@ -39,24 +39,24 @@
 	((reg_model)->minx < (9*(reg_model)->maxx)/10 && (reg_model)->nsample >= STARPU_CALIBRATION_MINIMUM)
 
 static pthread_rwlock_t registered_models_rwlock;
-static struct starpu_model_list_t *registered_models = NULL;
+static struct starpu_model_list *registered_models = NULL;
 
 /*
  * History based model
  */
 
 
-static void insert_history_entry(struct starpu_history_entry_t *entry, struct starpu_history_list_t **list, struct starpu_htbl32_node_s **history_ptr)
+static void insert_history_entry(struct starpu_history_entry *entry, struct starpu_history_list **list, struct starpu_htbl32_node **history_ptr)
 {
-	struct starpu_history_list_t *link;
-	struct starpu_history_entry_t *old;
+	struct starpu_history_list *link;
+	struct starpu_history_entry *old;
 
-	link = (struct starpu_history_list_t *) malloc(sizeof(struct starpu_history_list_t));
+	link = (struct starpu_history_list *) malloc(sizeof(struct starpu_history_list));
 	link->next = *list;
 	link->entry = entry;
 	*list = link;
 
-	old = (struct starpu_history_entry_t *) _starpu_htbl_insert_32(history_ptr, entry->footprint, entry);
+	old = (struct starpu_history_entry *) _starpu_htbl_insert_32(history_ptr, entry->footprint, entry);
 	/* that may fail in case there is some concurrency issue */
 	STARPU_ASSERT(old == NULL);
 }
@@ -64,10 +64,10 @@ static void insert_history_entry(struct starpu_history_entry_t *entry, struct st
 
 static void dump_reg_model(FILE *f, struct starpu_perfmodel *model, unsigned arch, unsigned nimpl)
 {
-	struct starpu_per_arch_perfmodel_t *per_arch_model;
+	struct starpu_per_arch_perfmodel *per_arch_model;
 
 	per_arch_model = &model->per_arch[arch][nimpl];
-	struct starpu_regression_model_t *reg_model;
+	struct starpu_regression_model *reg_model;
 	reg_model = &per_arch_model->regression;
 
 	/*
@@ -101,7 +101,7 @@ static void dump_reg_model(FILE *f, struct starpu_perfmodel *model, unsigned arc
 	fprintf(f, "%-15le\t%-15le\t%-15le\n", a, b, c);
 }
 
-static void scan_reg_model(FILE *f, struct starpu_regression_model_t *reg_model)
+static void scan_reg_model(FILE *f, struct starpu_regression_model *reg_model)
 {
 	int res;
 
@@ -136,12 +136,12 @@ static void scan_reg_model(FILE *f, struct starpu_regression_model_t *reg_model)
 	reg_model->nl_valid = !nl_invalid && VALID_REGRESSION(reg_model);
 }
 
-static void dump_history_entry(FILE *f, struct starpu_history_entry_t *entry)
+static void dump_history_entry(FILE *f, struct starpu_history_entry *entry)
 {
 	fprintf(f, "%08x\t%-15lu\t%-15le\t%-15le\t%-15le\t%-15le\t%u\n", entry->footprint, (unsigned long) entry->size, entry->mean, entry->deviation, entry->sum, entry->sum2, entry->nsample);
 }
 
-static void scan_history_entry(FILE *f, struct starpu_history_entry_t *entry)
+static void scan_history_entry(FILE *f, struct starpu_history_entry *entry)
 {
 	int res;
 
@@ -180,7 +180,7 @@ static void scan_history_entry(FILE *f, struct starpu_history_entry_t *entry)
 	}
 }
 
-static void parse_per_arch_model_file(FILE *f, struct starpu_per_arch_perfmodel_t *per_arch_model, unsigned scan_history)
+static void parse_per_arch_model_file(FILE *f, struct starpu_per_arch_perfmodel *per_arch_model, unsigned scan_history)
 {
 	unsigned nentries;
 
@@ -194,10 +194,10 @@ static void parse_per_arch_model_file(FILE *f, struct starpu_per_arch_perfmodel_
 	/* parse cpu entries */
 	unsigned i;
 	for (i = 0; i < nentries; i++) {
-		struct starpu_history_entry_t *entry = NULL;
+		struct starpu_history_entry *entry = NULL;
 		if (scan_history)
 		{
-			entry = (struct starpu_history_entry_t *) malloc(sizeof(struct starpu_history_entry_t));
+			entry = (struct starpu_history_entry *) malloc(sizeof(struct starpu_history_entry));
 			STARPU_ASSERT(entry);
 		}
 
@@ -211,7 +211,7 @@ static void parse_per_arch_model_file(FILE *f, struct starpu_per_arch_perfmodel_
 
 static void parse_arch(FILE *f, struct starpu_perfmodel *model, unsigned scan_history, unsigned archmin, unsigned archmax, int skiparch)
 {
-	struct starpu_per_arch_perfmodel_t dummy;
+	struct starpu_per_arch_perfmodel dummy;
 	int nimpls, implmax, skipimpl, impl;
 	unsigned ret, arch;
 	
@@ -323,11 +323,11 @@ static void parse_model_file(FILE *f, struct starpu_perfmodel *model, unsigned s
 
 static void dump_per_arch_model_file(FILE *f, struct starpu_perfmodel *model, unsigned arch, unsigned nimpl)
 {
-	struct starpu_per_arch_perfmodel_t *per_arch_model;
+	struct starpu_per_arch_perfmodel *per_arch_model;
 
 	per_arch_model = &model->per_arch[arch][nimpl];
 	/* count the number of elements in the lists */
-	struct starpu_history_list_t *ptr = NULL;
+	struct starpu_history_list *ptr = NULL;
 	unsigned nentries = 0;
 
 	if (model->type == STARPU_HISTORY_BASED || model->type == STARPU_NL_REGRESSION_BASED)
@@ -364,10 +364,10 @@ static void dump_per_arch_model_file(FILE *f, struct starpu_perfmodel *model, un
 
 static unsigned get_n_entries(struct starpu_perfmodel *model, unsigned arch, unsigned impl)
 {
-	struct starpu_per_arch_perfmodel_t *per_arch_model;
+	struct starpu_per_arch_perfmodel *per_arch_model;
 	per_arch_model = &model->per_arch[arch][impl];
 	/* count the number of elements in the lists */
-	struct starpu_history_list_t *ptr = NULL;
+	struct starpu_history_list *ptr = NULL;
 	unsigned nentries = 0;
 
 	if (model->type == STARPU_HISTORY_BASED || model->type == STARPU_NL_REGRESSION_BASED)
@@ -489,7 +489,7 @@ static void dump_model_file(FILE *f, struct starpu_perfmodel *model)
 	}
 }
 
-static void initialize_per_arch_model(struct starpu_per_arch_perfmodel_t *per_arch_model)
+static void initialize_per_arch_model(struct starpu_per_arch_perfmodel *per_arch_model)
 {
 	per_arch_model->history = NULL;
 	per_arch_model->list = NULL;
@@ -550,7 +550,7 @@ int _starpu_register_model(struct starpu_perfmodel *model)
 	}
 
 	/* add the model to a linked list */
-	struct starpu_model_list_t *node = (struct starpu_model_list_t *) malloc(sizeof(struct starpu_model_list_t));
+	struct starpu_model_list *node = (struct starpu_model_list *) malloc(sizeof(struct starpu_model_list));
 
 	node->model = model;
 	//model->debug_modelid = debug_modelid++;
@@ -621,7 +621,7 @@ static void _starpu_dump_registered_models(void)
 {
 	_STARPU_PTHREAD_RWLOCK_WRLOCK(&registered_models_rwlock);
 
-	struct starpu_model_list_t *node;
+	struct starpu_model_list *node;
 	node = registered_models;
 
 	_STARPU_DEBUG("DUMP MODELS !\n");
@@ -860,7 +860,7 @@ double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel *model
 {
 	double exp = -1.0;
 	size_t size = _starpu_job_get_data_size(j);
-	struct starpu_regression_model_t *regmodel;
+	struct starpu_regression_model *regmodel;
 
 	regmodel = &model->per_arch[arch][nimpl].regression;
 
@@ -874,7 +874,7 @@ double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfm
 {
 	double exp = -1.0;
 	size_t size = _starpu_job_get_data_size(j);
-	struct starpu_regression_model_t *regmodel;
+	struct starpu_regression_model *regmodel;
 
 	regmodel = &model->per_arch[arch][nimpl].regression;
 
@@ -882,12 +882,12 @@ double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfm
 		exp = regmodel->a*pow((double)size, regmodel->b) + regmodel->c;
 	else {
 		uint32_t key = _starpu_compute_buffers_footprint(j);
-		struct starpu_per_arch_perfmodel_t *per_arch_model = &model->per_arch[arch][nimpl];
-		struct starpu_htbl32_node_s *history = per_arch_model->history;
-		struct starpu_history_entry_t *entry;
+		struct starpu_per_arch_perfmodel *per_arch_model = &model->per_arch[arch][nimpl];
+		struct starpu_htbl32_node *history = per_arch_model->history;
+		struct starpu_history_entry *entry;
 
 		_STARPU_PTHREAD_RWLOCK_RDLOCK(&model->model_rwlock);
-		entry = (struct starpu_history_entry_t *) _starpu_htbl_search_32(history, key);
+		entry = (struct starpu_history_entry *) _starpu_htbl_search_32(history, key);
 		_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 
 		if (entry && entry->nsample >= STARPU_CALIBRATION_MINIMUM)
@@ -905,9 +905,9 @@ double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfm
 double _starpu_history_based_job_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_job_s *j,unsigned nimpl)
 {
 	double exp;
-	struct starpu_per_arch_perfmodel_t *per_arch_model;
-	struct starpu_history_entry_t *entry;
-	struct starpu_htbl32_node_s *history;
+	struct starpu_per_arch_perfmodel *per_arch_model;
+	struct starpu_history_entry *entry;
+	struct starpu_htbl32_node *history;
 
 	uint32_t key = _starpu_compute_buffers_footprint(j);
 
@@ -918,7 +918,7 @@ double _starpu_history_based_job_expected_perf(struct starpu_perfmodel *model, e
 		return -1.0;
 
 	_STARPU_PTHREAD_RWLOCK_RDLOCK(&model->model_rwlock);
-	entry = (struct starpu_history_entry_t *) _starpu_htbl_search_32(history, key);
+	entry = (struct starpu_history_entry *) _starpu_htbl_search_32(history, key);
 	_STARPU_PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
 
 	exp = entry?entry->mean:-1.0;
@@ -944,29 +944,29 @@ void _starpu_update_perfmodel_history(starpu_job_t j, struct starpu_perfmodel *m
 	{
 		_STARPU_PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
 
-		struct starpu_per_arch_perfmodel_t *per_arch_model = &model->per_arch[arch][nimpl];
+		struct starpu_per_arch_perfmodel *per_arch_model = &model->per_arch[arch][nimpl];
 
 		if (model->type == STARPU_HISTORY_BASED || model->type == STARPU_NL_REGRESSION_BASED)
 		{
 			uint32_t key = _starpu_compute_buffers_footprint(j);
-			struct starpu_history_entry_t *entry;
+			struct starpu_history_entry *entry;
 
-			struct starpu_htbl32_node_s *history;
-			struct starpu_htbl32_node_s **history_ptr;
+			struct starpu_htbl32_node *history;
+			struct starpu_htbl32_node **history_ptr;
 
-			struct starpu_history_list_t **list;
+			struct starpu_history_list **list;
 
 
 			history = per_arch_model->history;
 			history_ptr = &per_arch_model->history;
 			list = &per_arch_model->list;
 
-			entry = (struct starpu_history_entry_t *) _starpu_htbl_search_32(history, key);
+			entry = (struct starpu_history_entry *) _starpu_htbl_search_32(history, key);
 
 			if (!entry)
 			{
 				/* this is the first entry with such a footprint */
-				entry = (struct starpu_history_entry_t *) malloc(sizeof(struct starpu_history_entry_t));
+				entry = (struct starpu_history_entry *) malloc(sizeof(struct starpu_history_entry));
 				STARPU_ASSERT(entry);
 					entry->mean = measured;
 					entry->sum = measured;
@@ -998,7 +998,7 @@ void _starpu_update_perfmodel_history(starpu_job_t j, struct starpu_perfmodel *m
 			
 		if (model->type == STARPU_REGRESSION_BASED || model->type == STARPU_NL_REGRESSION_BASED)
 		{
-			struct starpu_regression_model_t *reg_model;
+			struct starpu_regression_model *reg_model;
 			reg_model = &per_arch_model->regression;
 
 			/* update the regression model */

src/core/perfmodel/regression.c

@@ -112,11 +112,11 @@ static double test_r(double c, unsigned n, unsigned *x, double *y)
 	return r;
 }
 
-static unsigned find_list_size(struct starpu_history_list_t *list_history)
+static unsigned find_list_size(struct starpu_history_list *list_history)
 {
 	unsigned cnt = 0;
 
-	struct starpu_history_list_t *ptr = list_history;
+	struct starpu_history_list *ptr = list_history;
 	while (ptr) {
 		cnt++;
 		ptr = ptr->next;
@@ -138,9 +138,9 @@ static double find_list_min(double *y, unsigned n)
 	return min;
 }
 
-static void dump_list(unsigned *x, double *y, struct starpu_history_list_t *list_history)
+static void dump_list(unsigned *x, double *y, struct starpu_history_list *list_history)
 {
-	struct starpu_history_list_t *ptr = list_history;
+	struct starpu_history_list *ptr = list_history;
 	unsigned i = 0;
 
 	while (ptr) {
@@ -157,7 +157,7 @@ static void dump_list(unsigned *x, double *y, struct starpu_history_list_t *list
  * 	return 0 if success, -1 otherwise
  * 	if success, a, b and c are modified
  * */
-int _starpu_regression_non_linear_power(struct starpu_history_list_t *ptr, double *a, double *b, double *c)
+int _starpu_regression_non_linear_power(struct starpu_history_list *ptr, double *a, double *b, double *c)
 {
 	unsigned n = find_list_size(ptr);
 

src/core/perfmodel/regression.h

@@ -24,6 +24,6 @@
 #include <core/perfmodel/perfmodel.h>
 #include <starpu.h>
 
-int _starpu_regression_non_linear_power(struct starpu_history_list_t *ptr, double *a, double *b, double *c);
+int _starpu_regression_non_linear_power(struct starpu_history_list *ptr, double *a, double *b, double *c);
 
 #endif // __REGRESSION_H__ 

src/core/topology.c

@@ -50,7 +50,7 @@ static void _starpu_initialize_workers_bindid(struct starpu_machine_config_s *co
 #if defined(STARPU_USE_CUDA) || defined(STARPU_USE_OPENCL)
 #  ifdef STARPU_USE_CUDA
 static void _starpu_initialize_workers_cuda_gpuid(struct starpu_machine_config_s *config);
-static struct starpu_htbl32_node_s *devices_using_cuda = NULL;
+static struct starpu_htbl32_node *devices_using_cuda = NULL;
 #  endif
 #  ifdef STARPU_USE_OPENCL
 static void _starpu_initialize_workers_opencl_gpuid(struct starpu_machine_config_s *config);
@@ -105,7 +105,7 @@ static void _starpu_initialize_workers_opencl_gpuid(struct starpu_machine_config
 #endif /* STARPU_USE_CUDA */
         {
                 // Detect identical devices
-                struct starpu_htbl32_node_s *devices_already_used = NULL;
+                struct starpu_htbl32_node *devices_already_used = NULL;
                 unsigned tmp[STARPU_NMAXWORKERS];
                 unsigned nb=0;
                 int i;

src/drivers/gordon/driver_gordon.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009, 2010, 2011  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  * Copyright (C) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -100,7 +100,7 @@ static void starpu_to_gordon_buffers(starpu_job_t j, struct gordon_ppu_job_s *go
 	unsigned nbuffers = cl->nbuffers;
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
-		struct starpu_buffer_descr_t *descr;
+		struct starpu_buffer_descr *descr;
 		descr = &task->buffers[buffer];
 
 		switch (descr->mode) {
@@ -120,7 +120,7 @@ static void starpu_to_gordon_buffers(starpu_job_t j, struct gordon_ppu_job_s *go
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
 		unsigned gordon_buffer;
-		struct starpu_buffer_descr_t *descr;
+		struct starpu_buffer_descr *descr;
 		descr = &task->buffers[buffer];
 
 		switch (descr->mode) {

tools/dev/rename.sed

@@ -14,7 +14,15 @@
 #
 # See the GNU Lesser General Public License in COPYING.LGPL for more details.
 
-s/\bstarpu_buffer_descr\b/struct starpu_buffer_descr/g
+s/\bstarpu_htbl32_node_s\b/starpu_htbl32_node/g
+s/\bstarpu_history_list_t\b/starpu_history_list/g
+s/\bstarpu_buffer_descr_t\b/starpu_buffer_descr/g
+s/\bstarpu_history_entry_t\b/starpu_history_entry/g
+s/\bstarpu_history_list_t\b/starpu_history_list/g
+s/\bstarpu_model_list_t\b/starpu_model_list/g
+s/\bstarpu_regression_model_t\b/starpu_regression_model/g
+s/\bstarpu_per_arch_perfmodel_t\b/starpu_per_arch_perfmodel/g
+#s/\bstarpu_buffer_descr\b/struct starpu_buffer_descr/g
 s/\bstarpu_perfmodel_t\b/starpu_perfmodel/g
 s/\bstarpu_tag_t\b/starpu_tag/g
 s/\bstarpu_sched_policy_s\b/starpu_sched_policy/g

tools/starpu_perfmodel_display.c

@@ -107,9 +107,9 @@ static void parse_args(int argc, char **argv)
 	}
 }
 
-static void display_history_based_perf_model(struct starpu_per_arch_perfmodel_t *per_arch_model)
+static void display_history_based_perf_model(struct starpu_per_arch_perfmodel *per_arch_model)
 {
-	struct starpu_history_list_t *ptr;
+	struct starpu_history_list *ptr;
 
 	ptr = per_arch_model->list;
 
@@ -117,7 +117,7 @@ static void display_history_based_perf_model(struct starpu_per_arch_perfmodel_t
 		fprintf(stderr, "# hash\t\tsize\t\tmean\t\tdev\t\tn\n");
 
 	while (ptr) {
-		struct starpu_history_entry_t *entry = ptr->entry;
+		struct starpu_history_entry *entry = ptr->entry;
 		if (!display_specific_footprint || (entry->footprint == specific_footprint))
 		{
 			if (!parameter)
@@ -145,7 +145,7 @@ static void display_history_based_perf_model(struct starpu_per_arch_perfmodel_t
 
 static void display_perf_model(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, unsigned nimpl)
 {
-	struct starpu_per_arch_perfmodel_t *arch_model = &model->per_arch[arch][nimpl];
+	struct starpu_per_arch_perfmodel *arch_model = &model->per_arch[arch][nimpl];
 	char archname[32];
 
 	if (arch_model->regression.nsample || arch_model->regression.valid || arch_model->regression.nl_valid || arch_model->list) {

tools/starpu_perfmodel_plot.c

@@ -147,7 +147,7 @@ static void display_perf_model(FILE *gnuplot_file, struct starpu_perfmodel *mode
 	char arch_name[256];
 	starpu_perfmodel_get_arch_name(arch, arch_name, 256, nimpl);
 
-	struct starpu_per_arch_perfmodel_t *arch_model =
+	struct starpu_per_arch_perfmodel *arch_model =
 		&model->per_arch[arch][nimpl];
 
 	if (arch_model->regression.valid || arch_model->regression.nl_valid)
@@ -193,7 +193,7 @@ static void display_history_based_perf_models(FILE *gnuplot_file, struct starpu_
 	char *command;
 	FILE *datafile;
 	unsigned arch;
-	struct starpu_history_list_t *ptr;
+	struct starpu_history_list *ptr;
 	char archname[32];
 	int col;
 	int len;
@@ -208,7 +208,7 @@ static void display_history_based_perf_models(FILE *gnuplot_file, struct starpu_
 	unsigned implid;
 	for (arch = arch1; arch < arch2; arch++) {
 		for (implid = 0; implid < STARPU_MAXIMPLEMENTATIONS; implid++) {
-			struct starpu_per_arch_perfmodel_t *arch_model = &model->per_arch[arch][implid];
+			struct starpu_per_arch_perfmodel *arch_model = &model->per_arch[arch][implid];
 			starpu_perfmodel_get_arch_name((enum starpu_perf_archtype) arch, archname, 32, implid);
 
 			//ptrs[arch-arch1][implid] = ptr[arch-arch1][implid] = arch_model->list;
@@ -228,7 +228,7 @@ static void display_history_based_perf_models(FILE *gnuplot_file, struct starpu_
 		/* Get the next minimum */
 		for (arch = arch1; arch < arch2; arch++)
 			for (implid = 0; implid < STARPU_MAXIMPLEMENTATIONS; implid++) {
-				struct starpu_per_arch_perfmodel_t *arch_model = &model->per_arch[arch][implid];
+				struct starpu_per_arch_perfmodel *arch_model = &model->per_arch[arch][implid];
 				for (ptr = arch_model->list; ptr; ptr = ptr->next) {
 					unsigned long size = ptr->entry->size;
 					if (size > last && size < minimum)
@@ -242,9 +242,9 @@ static void display_history_based_perf_models(FILE *gnuplot_file, struct starpu_
 		fprintf(datafile, "%-15lu ", minimum);
 		for (arch = arch1; arch < arch2; arch++) {
 			for (implid = 0; implid < STARPU_MAXIMPLEMENTATIONS; implid++) {
-				struct starpu_per_arch_perfmodel_t *arch_model = &model->per_arch[arch][implid];
+				struct starpu_per_arch_perfmodel *arch_model = &model->per_arch[arch][implid];
 				for (ptr = arch_model->list; ptr; ptr = ptr->next) {
-					struct starpu_history_entry_t *entry = ptr->entry;
+					struct starpu_history_entry *entry = ptr->entry;
 					if (entry->size == minimum) {
 						fprintf(datafile, "\t%-15le\t%-15le", 0.001*entry->mean, 0.001*entry->deviation);
 						break;