expr3_elem_size, nelems, expr3, e3_arr_desc,
e3_has_nodescriptor, expr, &element_size);
- if (dimension || (flag_coarray == GFC_FCOARRAY_SHARED && coarray))
+ if (dimension && !(flag_coarray == GFC_FCOARRAY_SHARED && coarray))
{
var_overflow = gfc_create_var (integer_type_node, "overflow");
gfc_add_modify (&se->pre, var_overflow, overflow);
else
gfc_allocate_using_malloc (&elseblock, pointer, size, status);
- if (dimension)
+ if (dimension && !(flag_coarray == GFC_FCOARRAY_SHARED && coarray))
{
cond = gfc_unlikely (fold_build2_loc (input_location, NE_EXPR,
logical_type_node, var_overflow, integer_zero_node),
void *ret;
pthread_mutex_lock (&iface->as->lock);
- shared_memory_prepare(iface->mem);
+ shared_memory_prepare (iface->mem);
res = hashmap_get (&iface->hm, id);
size_t found_size;
found_size = hm_search_result_size (&res);
if (found_size != size)
- {
- dprintf (2, "Size mismatch for coarray allocation id %p: "
- "found = %lu != size = %lu\n", (void *) id, found_size, size);
- pthread_mutex_unlock (&iface->as->lock);
+ {
+ dprintf (2,
+ "Size mismatch for coarray allocation id %p: found = %lu "
+ "!= size = %lu\n",
+ (void *)id, found_size, size);
+ pthread_mutex_unlock (&iface->as->lock);
exit (1);
- }
+ }
shared_ptr = hm_search_result_ptr (&res);
hashmap_inc (&iface->hm, id, &res);
}
holds that memory segment, decrease the reference count otherwise. */
void
-free_memory_with_id (alloc_iface* iface, memid id)
+free_memory_with_id (alloc_iface *iface, memid id)
{
hashmap_search_result res;
int entries_left;
pthread_mutex_lock (&iface->as->lock);
- shared_memory_prepare(iface->mem);
+ shared_memory_prepare (iface->mem);
res = hashmap_get (&iface->hm, id);
if (!hm_search_result_contains (&res))
{
pthread_mutex_unlock (&iface->as->lock);
char buffer[100];
- snprintf (buffer, sizeof(buffer), "Error in free_memory_with_id: "
- "%p not found", (void *) id);
+ snprintf (buffer, sizeof (buffer),
+ "Error in free_memory_with_id: %p not found", (void *)id);
/* FIXME: For some reason, internal_error (NULL, buffer) fails to link,
* so we use dprintf at the moment. */
dprintf (2, buffer);
}
entries_left = hashmap_dec (&iface->hm, id, &res);
- assert (entries_left >=0);
+ assert (entries_left >= 0);
if (entries_left == 0)
{
shared_free (&iface->alloc, hm_search_result_ptr (&res),
- hm_search_result_size (&res));
+ hm_search_result_size (&res));
}
pthread_mutex_unlock (&iface->as->lock);
void
alloc_iface_init (alloc_iface *iface, shared_memory *mem)
{
-
+
iface->as = SHARED_MEMORY_RAW_ALLOC_PTR (mem, alloc_iface_shared);
iface->mem = mem;
initialize_shared_mutex (&iface->as->lock);
}
allocator *
-get_allocator (alloc_iface * iface)
+get_allocator (alloc_iface *iface)
{
return &iface->alloc;
}
#include "shared_memory.h"
#include "allocator.h"
-typedef struct {
+typedef struct
+{
shared_mem_ptr next;
} bucket;
/* Initialize the allocator. */
-void
+void
allocator_init (allocator *a, allocator_shared *s, shared_memory *sm)
{
a->s = s;
#define MAX_ALIGN 16
-shared_mem_ptr
+shared_mem_ptr
shared_malloc (allocator *a, size_t size)
{
shared_mem_ptr ret;
sz = next_power_of_two (size);
act_size = sz > sizeof (bucket) ? sz : sizeof (bucket);
- bucket_list_index = __builtin_clzl(act_size);
+ bucket_list_index = __builtin_clzl (act_size);
if (SHMPTR_IS_NULL (a->s->free_bucket_head[bucket_list_index]))
return shared_memory_get_mem_with_alignment (a->shm, act_size, MAX_ALIGN);
ret = a->s->free_bucket_head[bucket_list_index];
a->s->free_bucket_head[bucket_list_index]
- = (SHMPTR_AS (bucket *, ret, a->shm)->next);
- assert(ret.offset != 0);
+ = (SHMPTR_AS (bucket *, ret, a->shm)->next);
+ assert (ret.offset != 0);
return ret;
}
/* Free memory. */
void
-shared_free (allocator *a, shared_mem_ptr p, size_t size) {
+shared_free (allocator *a, shared_mem_ptr p, size_t size)
+{
bucket *b;
size_t sz;
int bucket_list_index;
sz = next_power_of_two (size);
act_size = sz > sizeof (bucket) ? sz : sizeof (bucket);
- bucket_list_index = __builtin_clzl(act_size);
+ bucket_list_index = __builtin_clzl (act_size);
- b = SHMPTR_AS(bucket *, p, a->shm);
+ b = SHMPTR_AS (bucket *, p, a->shm);
b->next = a->s->free_bucket_head[bucket_list_index];
a->s->free_bucket_head[bucket_list_index] = p;
}
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-
#include "libgfortran.h"
#include "libcoarraynative.h"
#include "allocator.h"
nca_local_data *local = NULL;
-image this_image = {-1, NULL};
+image this_image = { -1, NULL };
/* Get image number from environment or sysconf. */
get_master (void)
{
master *m;
- m = SHMPTR_AS (master *,
- shared_memory_get_mem_with_alignment
- (&local->sm,
- sizeof (master) + sizeof(image_status) * local->total_num_images,
- __alignof__(master)), &local->sm);
+ m = SHMPTR_AS (
+ master *,
+ shared_memory_get_mem_with_alignment (
+ &local->sm,
+ sizeof (master) + sizeof (image_status) * local->total_num_images,
+ __alignof__(master)),
+ &local->sm);
m->has_failed_image = 0;
m->finished_images = 0;
waitable_counter_init (&m->num_active_images, local->total_num_images);
return m;
}
-
/* Ensure things are initialized. */
-void
-ensure_initialization(void)
+void
+ensure_initialization (void)
{
if (local)
return;
- local = malloc(sizeof(nca_local_data)); // Is malloc already init'ed at that
- // point? Maybe use mmap(MAP_ANON)
- // instead
- pagesize = sysconf (_SC_PAGE_SIZE);
+ local = malloc (sizeof (nca_local_data)); // Is malloc already init'ed at
+ // that point? Maybe use
+ // mmap(MAP_ANON) instead
+ pagesize = sysconf (_SC_PAGE_SIZE);
local->total_num_images = get_environ_image_num ();
shared_memory_init (&local->sm);
shared_memory_prepare (&local->sm);
- if (this_image.m == NULL) /* A bit of a hack, but we
- need the master early. */
- this_image.m = get_master();
+ if (this_image.m == NULL) /* A bit of a hack, but we
+ need the master early. */
+ this_image.m = get_master ();
alloc_iface_init (&local->ai, &local->sm);
collsub_iface_init (&local->ci, &local->ai, &local->sm);
sync_iface_init (&local->si, &local->ai, &local->sm);
}
-
/* Test for failed or stopped images. */
int
-test_for_cas_errors (int *stat, char *errmsg, size_t errmsg_length)
+test_for_cas_errors (int *stat, char *errmsg, size_t errmsg_length)
{
size_t errmsg_written_bytes;
if (!stat)
*stat = CAS_STAT_STOPPED_IMAGE;
if (errmsg)
{
- errmsg_written_bytes
- = snprintf(errmsg, errmsg_length,
- "Stopped images present (currently %d)",
- this_image.m->finished_images);
+ errmsg_written_bytes = snprintf (errmsg, errmsg_length,
+ "Stopped images present (currently "
+ "%d)",
+ this_image.m->finished_images);
if (errmsg_written_bytes > errmsg_length - 1)
errmsg_written_bytes = errmsg_length - 1;
-
- memset(errmsg + errmsg_written_bytes, ' ',
- errmsg_length - errmsg_written_bytes);
+
+ memset (errmsg + errmsg_written_bytes, ' ',
+ errmsg_length - errmsg_written_bytes);
}
}
else if (this_image.m->has_failed_image)
{
*stat = CAS_STAT_FAILED_IMAGE;
- if (errmsg)
- {
- errmsg_written_bytes
- = snprintf(errmsg, errmsg_length,
- "Failed images present (currently %d)",
- this_image.m->has_failed_image);
- if (errmsg_written_bytes > errmsg_length - 1)
- errmsg_written_bytes = errmsg_length - 1;
-
- memset(errmsg + errmsg_written_bytes, ' ',
- errmsg_length - errmsg_written_bytes);
+ if (errmsg)
+ {
+ errmsg_written_bytes = snprintf (errmsg, errmsg_length,
+ "Failed images present (currently "
+ "%d)",
+ this_image.m->has_failed_image);
+ if (errmsg_written_bytes > errmsg_length - 1)
+ errmsg_written_bytes = errmsg_length - 1;
+
+ memset (errmsg + errmsg_written_bytes, ' ',
+ errmsg_length - errmsg_written_bytes);
+ }
}
- }
else
{
*stat = 0;
/* Check if an image is active. */
-int
-master_is_image_active (master *m, int image_num)
+int
+master_is_image_active (master *m, int image_num)
{
return m->images[image_num].status == IMAGE_OK;
}
/* Get number of active images. */
int
-master_get_num_active_images (master *m)
+master_get_num_active_images (master *m)
{
- return waitable_counter_get_val(&m->num_active_images);
+ return waitable_counter_get_val (&m->num_active_images);
}
/* Bind barrier to counter. */
void
-master_bind_active_image_barrier(master *m, counter_barrier *b)
+master_bind_active_image_barrier (master *m, counter_barrier *b)
{
- bind_counter_barrier(b, &m->num_active_images);
+ bind_counter_barrier (b, &m->num_active_images);
}
/* Main wrapper. */
-static void __attribute__((noreturn))
+static void __attribute__ ((noreturn))
image_main_wrapper (void (*image_main) (void), image *this)
{
this_image = *this;
- sync_all(&local->si);
+ sync_all (&local->si);
image_main ();
}
void
-error_on_missing_images(void) {
- if (master_get_num_active_images(this_image.m) != local->total_num_images)
- exit(1);
+error_on_missing_images (void)
+{
+ if (master_get_num_active_images (this_image.m) != local->total_num_images)
+ exit (1);
}
/* This is called from main, with a pointer to the user's program as
argument. It forks the images and waits for their completion. */
void
-cas_master (void (*image_main) (void)) {
+cas_master (void (*image_main) (void))
+{
master *m;
int i, j;
pid_t new;
image im;
int exit_code = 0;
int chstatus;
- ensure_initialization();
+ ensure_initialization ();
m = this_image.m;
im.m = m;
- for (im.image_num = 0; im.image_num < local->total_num_images; im.image_num++)
+ for (im.image_num = 0; im.image_num < local->total_num_images;
+ im.image_num++)
{
- if ((new = fork()))
- {
+ if ((new = fork ()))
+ {
if (new == -1)
{
- dprintf(2, "error spawning child\n");
+ dprintf (2, "error spawning child\n");
exit_code = 1;
}
m->images[im.image_num].pid = new;
m->images[im.image_num].status = IMAGE_OK;
- }
+ }
else
- image_main_wrapper(image_main, &im);
+ image_main_wrapper (image_main, &im);
}
for (i = 0; i < local->total_num_images; i++)
{
if (WIFEXITED (chstatus) && !WEXITSTATUS (chstatus))
{
j = 0;
- for (; j < local->total_num_images && m->images[j].pid != new; j++);
+ for (; j < local->total_num_images && m->images[j].pid != new; j++)
+ ;
m->images[j].status = IMAGE_SUCCESS;
m->finished_images++; /* FIXME: Needs to be atomic, probably. */
}
else if (!WIFEXITED (chstatus) || WEXITSTATUS (chstatus))
{
j = 0;
- for (; j < local->total_num_images && m->images[j].pid != new; j++);
+ for (; j < local->total_num_images && m->images[j].pid != new; j++)
+ ;
m->images[j].status = IMAGE_FAILED;
m->has_failed_image++; /* FIXME: Needs to be atomic, probably. */
for (; j < local->total_num_images; j++)
dprintf (2, "ERROR: Image %d(%#x) failed\n", j, new);
exit_code = 1;
}
- waitable_counter_add(&m->num_active_images, -1);
+ waitable_counter_add (&m->num_active_images, -1);
}
exit (exit_code);
}
return ret;
}
-
/* This function syncs all images with one another. It will only return once
all images have called it. */
counter_barrier_wait (&ci->s->barrier);
}
-
/* assign_function is needed since we only know how to assign the type inside
the compiler. It should be implemented as follows:
-
- void assign_function (void *a, void *b)
+
+ void assign_function (void *a, void *b)
{
*((t *) a) = reduction_operation ((t *) a, (t *) b);
}
-
+
*/
void
-collsub_reduce_array (collsub_iface *ci, gfc_array_char *desc, int *result_image,
+collsub_reduce_array (collsub_iface *ci, gfc_array_char *desc,
+ int *result_image,
void (*assign_function) (void *, void *))
{
void *buffer;
index_type this_image_size_bytes;
char *this_image_buf;
- error_on_missing_images();
+ error_on_missing_images ();
packed = pack_array_prepare (&pi, desc);
if (pi.num_elem == 0)
elem_size = GFC_DESCRIPTOR_SIZE (desc);
this_image_size_bytes = elem_size * pi.num_elem;
- buffer = get_collsub_buf (ci, this_image_size_bytes * local->total_num_images);
+ buffer
+ = get_collsub_buf (ci, this_image_size_bytes * local->total_num_images);
this_image_buf = buffer + this_image_size_bytes * this_image.image_num;
if (packed)
pack_array_finish (&pi, desc, this_image_buf);
collsub_sync (ci);
-
- for (; ((this_image.image_num >> cbit) & 1) == 0 && (local->total_num_images >> cbit) != 0; cbit++)
+ for (; ((this_image.image_num >> cbit) & 1) == 0
+ && (local->total_num_images >> cbit) != 0;
+ cbit++)
{
imoffset = 1 << cbit;
if (this_image.image_num + imoffset < local->total_num_images)
/* Reduce arrays elementwise. */
- for (ssize_t i = 0; i < pi.num_elem; i++)
+ for (ssize_t i = 0; i < pi.num_elem; i++)
assign_function (this_image_buf + elem_size * i,
- this_image_buf + this_image_size_bytes * imoffset + elem_size * i);
-
+ this_image_buf + this_image_size_bytes * imoffset
+ + elem_size * i);
+
collsub_sync (ci);
}
- for ( ; (local->total_num_images >> cbit) != 0; cbit++)
+ for (; (local->total_num_images >> cbit) != 0; cbit++)
collsub_sync (ci);
-
+
if (!result_image || *result_image == this_image.image_num)
- {
+ {
if (packed)
- memcpy (GFC_DESCRIPTOR_DATA (desc), buffer, this_image_size_bytes);
+ memcpy (GFC_DESCRIPTOR_DATA (desc), buffer, this_image_size_bytes);
else
- unpack_array_finish(&pi, desc, buffer);
+ unpack_array_finish (&pi, desc, buffer);
}
- finish_collective_subroutine (ci);
+ finish_collective_subroutine (ci);
}
void
int imoffset;
char *this_image_buf;
- error_on_missing_images();
+ error_on_missing_images ();
- buffer = get_collsub_buf (ci, elem_size * master_get_num_active_images(this_image.m));
+ buffer = get_collsub_buf (
+ ci, elem_size * master_get_num_active_images (this_image.m));
this_image_buf = buffer + elem_size * this_image.image_num;
memcpy (this_image_buf, obj, elem_size);
-
collsub_sync (ci);
- for (; ((this_image.image_num >> cbit) & 1) == 0 && (local->total_num_images >> cbit) != 0; cbit++)
+ for (; ((this_image.image_num >> cbit) & 1) == 0
+ && (local->total_num_images >> cbit) != 0;
+ cbit++)
{
imoffset = 1 << cbit;
-
- if (this_image.image_num + imoffset < local->total_num_images) {
- /* Reduce arrays elementwise. */
- assign_function (this_image_buf, this_image_buf + elem_size*imoffset);
- }
+
+ if (this_image.image_num + imoffset < local->total_num_images)
+ {
+ /* Reduce arrays elementwise. */
+ assign_function (this_image_buf,
+ this_image_buf + elem_size * imoffset);
+ }
collsub_sync (ci);
}
- for ( ; (master_get_num_active_images(this_image.m) >> cbit) != 0; cbit++)
+ for (; (master_get_num_active_images (this_image.m) >> cbit) != 0; cbit++)
collsub_sync (ci);
-
+
if (!result_image || *result_image == this_image.image_num)
- memcpy(obj, buffer, elem_size);
+ memcpy (obj, buffer, elem_size);
- finish_collective_subroutine (ci);
+ finish_collective_subroutine (ci);
}
/* Do not use sync_all(), because the program should deadlock in the case that
void
collsub_iface_init (collsub_iface *ci, alloc_iface *ai, shared_memory *sm)
{
- ci->s = SHARED_MEMORY_RAW_ALLOC_PTR(sm, collsub_iface_shared);
+ ci->s = SHARED_MEMORY_RAW_ALLOC_PTR (sm, collsub_iface_shared);
- ci->s->collsub_buf = shared_malloc(get_allocator(ai),
- sizeof(double)*local->total_num_images);
- ci->s->curr_size = sizeof(double)*local->total_num_images;
+ ci->s->collsub_buf = shared_malloc (
+ get_allocator (ai), sizeof (double) * local->total_num_images);
+ ci->s->curr_size = sizeof (double) * local->total_num_images;
ci->sm = sm;
- ci->a = get_allocator(ai);
+ ci->a = get_allocator (ai);
master_bind_active_image_barrier (this_image.m, &ci->s->barrier);
initialize_shared_mutex (&ci->s->mutex);
void
collsub_broadcast_scalar (collsub_iface *ci, void *obj, index_type elem_size,
- int source_image /* Adjusted in the wrapper. */)
+ int source_image /* Adjusted in the wrapper. */)
{
void *buffer;
collsub_sync (ci);
memcpy (obj, buffer, elem_size);
}
-
- finish_collective_subroutine (ci);
+
+ finish_collective_subroutine (ci);
}
void
-collsub_broadcast_array (collsub_iface *ci, gfc_array_char *desc,
+collsub_broadcast_array (collsub_iface *ci, gfc_array_char *desc,
int source_image)
{
void *buffer;
if (source_image == this_image.image_num)
{
if (packed)
- memcpy (buffer, GFC_DESCRIPTOR_DATA (desc), size_bytes);
+ memcpy (buffer, GFC_DESCRIPTOR_DATA (desc), size_bytes);
else
- pack_array_finish (&pi, desc, buffer);
+ pack_array_finish (&pi, desc, buffer);
collsub_sync (ci);
}
- else
+ else
{
collsub_sync (ci);
if (packed)
memcpy (GFC_DESCRIPTOR_DATA (desc), buffer, size_bytes);
else
- unpack_array_finish(&pi, desc, buffer);
+ unpack_array_finish (&pi, desc, buffer);
}
- finish_collective_subroutine (ci);
+ finish_collective_subroutine (ci);
}
/* Wait on the barrier. */
-void
+void
counter_barrier_wait (counter_barrier *b)
{
int initial_count;
assert (b->count);
lock_counter_barrier (b);
-
+
wait_group_beginning = b->curr_wait_group;
if (--b->wait_count <= 0)
else
{
while (b->wait_count > 0 && b->curr_wait_group == wait_group_beginning)
- pthread_cond_wait(&b->cond, &b->count->m);
+ pthread_cond_wait (&b->cond, &b->count->m);
}
if (b->wait_count <= 0)
{
counter_barrier *curr;
int ret;
- pthread_mutex_lock(&c->m);
+ pthread_mutex_lock (&c->m);
ret = (c->val += val);
- for (curr = c->b; curr; curr = curr->next)
- change_internal_barrier_count(curr, val);
+ for (curr = c->b; curr; curr = curr->next)
+ change_internal_barrier_count (curr, val);
- pthread_mutex_unlock(&c->m);
+ pthread_mutex_unlock (&c->m);
return ret;
}
waitable_counter_get_val (waitable_counter *c)
{
int ret;
- pthread_mutex_lock(&c->m);
+ pthread_mutex_lock (&c->m);
ret = c->val;
- pthread_mutex_unlock(&c->m);
+ pthread_mutex_unlock (&c->m);
return ret;
}
/* Initialize waitable counter. */
-void
+void
waitable_counter_init (waitable_counter *c, int val)
{
initialize_shared_mutex (&c->m);
/* Bind a barrier to a counter. */
-void
+void
bind_counter_barrier (counter_barrier *b, waitable_counter *c)
{
initialize_shared_condition (&b->cond);
b->wait_count = c->val;
c->b = b;
pthread_mutex_unlock (&c->m);
-
}
#include <string.h>
#define INITIAL_BITNUM (5)
-#define INITIAL_SIZE (1<<INITIAL_BITNUM)
+#define INITIAL_SIZE (1 << INITIAL_BITNUM)
#define CRITICAL_LOOKAHEAD (16)
static ssize_t n_ent;
-typedef struct {
+typedef struct
+{
memid id;
shared_mem_ptr p; /* If p == SHMPTR_NULL, the entry is empty. */
size_t s;
- int max_lookahead;
+ int max_lookahead;
int refcnt;
} hashmap_entry;
for (i = 0; i < size; i++)
{
if (!SHMPTR_IS_NULL (data[i].p))
- ret ++;
+ ret++;
}
return ret;
}
/* 64 bit to 64 bit hash function. */
/*
-static inline uint64_t
+static inline uint64_t
hash (uint64_t x)
{
return x * 11400714819323198485lu;
}
*/
-#define ASSERT_HM(hm, cond) assert_hashmap(hm, cond, #cond)
+#define ASSERT_HM(hm, cond) assert_hashmap (hm, cond, #cond)
-static void
-assert_hashmap(hashmap *hm, bool asserted, const char *cond)
+static void
+assert_hashmap (hashmap *hm, bool asserted, const char *cond)
{
if (!asserted)
{
- dprintf(2, cond);
- dump_hm(hm);
+ dprintf (2, cond);
+ dump_hm (hm);
}
- assert(asserted);
+ assert (asserted);
}
-static inline uint64_t
+static inline uint64_t
hash (uint64_t key)
{
key ^= (key >> 30);
return key;
}
-
/* Gets a pointer to the current data in the hashmap. */
static inline hashmap_entry *
-get_data(hashmap *hm)
+get_data (hashmap *hm)
{
- return SHMPTR_AS (hashmap_entry *, hm->s->data, hm->sm);
+ return SHMPTR_AS (hashmap_entry *, hm->s->data, hm->sm);
}
-
/* Generate mask from current number of bits. */
static inline intptr_t
return (1 << hm->s->bitnum) - 1;
}
-
/* Add with wrap-around at hashmap size. */
static inline size_t
-hmiadd (hashmap *hm, size_t s, ssize_t o) {
+hmiadd (hashmap *hm, size_t s, ssize_t o)
+{
return (s + o) & gen_mask (hm);
}
-
/* Get the expected offset for entry id. */
static inline ssize_t
get_expected_offset (hashmap *hm, memid id)
{
- return hash(id) >> (PTR_BITS - hm->s->bitnum);
+ return hash (id) >> (PTR_BITS - hm->s->bitnum);
}
-
/* Initialize the hashmap. */
-void
+void
hashmap_init (hashmap *hm, hashmap_shared *hs, allocator *a,
- shared_memory *mem)
+ shared_memory *mem)
{
hashmap_entry *data;
hm->s = hs;
hm->sm = mem;
- hm->s->data = shared_malloc (a, INITIAL_SIZE * sizeof(hashmap_entry));
+ hm->s->data = shared_malloc (a, INITIAL_SIZE * sizeof (hashmap_entry));
data = get_data (hm);
- memset(data, '\0', INITIAL_SIZE*sizeof(hashmap_entry));
+ memset (data, '\0', INITIAL_SIZE * sizeof (hashmap_entry));
for (int i = 0; i < INITIAL_SIZE; i++)
data[i].p = SHMPTR_NULL;
hm->a = a;
}
-
/* This checks if the entry id exists in that range the range between
the expected position and the maximum lookahead. */
-static ssize_t
+static ssize_t
scan_inside_lookahead (hashmap *hm, ssize_t expected_off, memid id)
{
ssize_t lookahead;
ASSERT_HM (hm, lookahead < CRITICAL_LOOKAHEAD);
for (int i = 0; i <= lookahead; i++) /* For performance, this could
- iterate backwards. */
+ iterate backwards. */
if (data[hmiadd (hm, expected_off, i)].id == id)
return hmiadd (hm, expected_off, i);
return -1;
}
-
/* Scan for the next empty slot we can use. Returns offset relative
to the expected position. */
{
hashmap_entry *data;
- data = get_data(hm);
- for (int i = 0; i < CRITICAL_LOOKAHEAD; i++)
+ data = get_data (hm);
+ for (int i = 0; i < CRITICAL_LOOKAHEAD; i++)
if (SHMPTR_IS_NULL (data[hmiadd (hm, expected_off, i)].p))
return i;
return -1;
}
-
/* Search the hashmap for id. */
-hashmap_search_result
+hashmap_search_result
hashmap_get (hashmap *hm, memid id)
{
hashmap_search_result ret;
- hashmap_entry *data;
+ hashmap_entry *data;
size_t expected_offset;
ssize_t res;
res = scan_inside_lookahead (hm, expected_offset, id);
if (res != -1)
- ret = ((hashmap_search_result)
- { .p = data[res].p, .size=data[res].s, .res_offset = res });
+ ret = ((hashmap_search_result){
+ .p = data[res].p, .size = data[res].s, .res_offset = res });
else
ret.p = SHMPTR_NULL;
return ret;
}
-
/* Return size of a hashmap search result. */
size_t
return res->size;
}
-
/* Return pointer of a hashmap search result. */
-shared_mem_ptr
+shared_mem_ptr
hm_search_result_ptr (hashmap_search_result *res)
{
return res->p;
}
-
/* Return pointer of a hashmap search result. */
-bool
+bool
hm_search_result_contains (hashmap_search_result *res)
{
- return !SHMPTR_IS_NULL(res->p);
+ return !SHMPTR_IS_NULL (res->p);
}
-
/* Enlarge hashmap memory. */
static void
old_data_p = hm->s->data;
old_size = hm->s->size;
- hm->s->data = shared_malloc (hm->a, (hm->s->size *= 2)*sizeof(hashmap_entry));
+ hm->s->data
+ = shared_malloc (hm->a, (hm->s->size *= 2) * sizeof (hashmap_entry));
hm->s->bitnum++;
- *data = get_data(hm);
+ *data = get_data (hm);
for (size_t i = 0; i < hm->s->size; i++)
- (*data)[i] = ((hashmap_entry) { .id = 0, .p = SHMPTR_NULL, .s=0,
- .max_lookahead = 0, .refcnt=0 });
+ (*data)[i] = ((hashmap_entry){
+ .id = 0, .p = SHMPTR_NULL, .s = 0, .max_lookahead = 0, .refcnt = 0 });
if (f)
- shared_free(hm->a, old_data_p, old_size);
+ shared_free (hm->a, old_data_p, old_size);
}
-
/* Resize hashmap. */
static void
/* old_data points to the old block containing the hashmap. We
redistribute the data from there into the new block. */
-
+
old_data_p = hm->s->data;
old_data = *data;
old_size = hm->s->size;
- enlarge_hashmap_mem (hm, &new_data, false);
- retry_resize:
+ enlarge_hashmap_mem (hm, &new_data, false);
+retry_resize:
for (size_t i = 0; i < old_size; i++)
{
if (SHMPTR_IS_NULL (old_data[i].p))
- continue;
+ continue;
id = old_data[i].id;
inital_index = get_expected_offset (hm, id);
new_offset = scan_empty (hm, inital_index);
/* If we didn't find a free slot, just resize the hashmap
- again. */
+ again. */
if (new_offset == -1)
- {
- enlarge_hashmap_mem (hm, &new_data, true);
- goto retry_resize; /* Sue me. */
- }
+ {
+ enlarge_hashmap_mem (hm, &new_data, true);
+ goto retry_resize; /* Sue me. */
+ }
ASSERT_HM (hm, new_offset < CRITICAL_LOOKAHEAD);
new_index = hmiadd (hm, inital_index, new_offset);
max_lookahead = new_data[inital_index].max_lookahead;
new_data[inital_index].max_lookahead
- = new_offset > max_lookahead ? new_offset : max_lookahead;
-
- new_data[new_index] = ((hashmap_entry) {.id = id, .p = old_data[i].p,
- .s = old_data[i].s,
- .max_lookahead = new_data[new_index].max_lookahead,
- .refcnt = old_data[i].refcnt});
+ = new_offset > max_lookahead ? new_offset : max_lookahead;
+
+ new_data[new_index] = ((hashmap_entry){
+ .id = id,
+ .p = old_data[i].p,
+ .s = old_data[i].s,
+ .max_lookahead = new_data[new_index].max_lookahead,
+ .refcnt = old_data[i].refcnt });
}
shared_free (hm->a, old_data_p, old_size);
*data = new_data;
}
-
/* Set an entry in the hashmap. */
-void
+void
hashmap_set (hashmap *hm, memid id, hashmap_search_result *hsr,
- shared_mem_ptr p, size_t size)
+ shared_mem_ptr p, size_t size)
{
hashmap_entry *data;
ssize_t expected_offset, lookahead;
ssize_t empty_offset;
ssize_t delta;
- data = get_data(hm);
+ data = get_data (hm);
- if (hsr) {
- data[hsr->res_offset].s = size;
- data[hsr->res_offset].p = p;
- return;
- }
+ if (hsr)
+ {
+ data[hsr->res_offset].s = size;
+ data[hsr->res_offset].p = p;
+ return;
+ }
expected_offset = get_expected_offset (hm, id);
while ((delta = scan_empty (hm, expected_offset)) == -1)
empty_offset = hmiadd (hm, expected_offset, delta);
lookahead = data[expected_offset].max_lookahead;
data[expected_offset].max_lookahead = delta > lookahead ? delta : lookahead;
- data[empty_offset] = ((hashmap_entry) {.id = id, .p = p, .s = size,
- .max_lookahead = data[empty_offset].max_lookahead,
- .refcnt = 1});
-
- n_ent ++;
+ data[empty_offset]
+ = ((hashmap_entry){ .id = id,
+ .p = p,
+ .s = size,
+ .max_lookahead = data[empty_offset].max_lookahead,
+ .refcnt = 1 });
+
+ n_ent++;
/* TODO: Shouldn't reset refcnt, but this doesn't matter at the
moment because of the way the function is used. */
}
/* Change the refcount of a hashmap entry. */
-static int
+static int
hashmap_change_refcnt (hashmap *hm, memid id, hashmap_search_result *res,
- int delta)
+ int delta)
{
hashmap_entry *data;
hashmap_search_result r;
data = get_data (hm);
- if (res)
+ if (res)
pr = res;
else
{
return ret;
}
-
/* Increase hashmap entry refcount. */
-void
-hashmap_inc (hashmap *hm, memid id, hashmap_search_result * res)
+void
+hashmap_inc (hashmap *hm, memid id, hashmap_search_result *res)
{
int ret;
ret = hashmap_change_refcnt (hm, id, res, 1);
ASSERT_HM (hm, ret > 0);
}
-
/* Decrease hashmap entry refcount. */
-int
-hashmap_dec (hashmap *hm, memid id, hashmap_search_result * res)
+int
+hashmap_dec (hashmap *hm, memid id, hashmap_search_result *res)
{
int ret;
ret = hashmap_change_refcnt (hm, id, res, -1);
return ret;
}
-#define PE(str, ...) fprintf(stderr, INDENT str, ##__VA_ARGS__)
+#define PE(str, ...) fprintf (stderr, INDENT str, ##__VA_ARGS__)
#define INDENT ""
void
-dump_hm(hashmap *hm) {
+dump_hm (hashmap *hm)
+{
hashmap_entry *data;
size_t exp;
size_t occ_num = 0;
- PE("h %p (size: %lu, bitnum: %d)\n", hm, hm->s->size, hm->s->bitnum);
+ PE ("h %p (size: %lu, bitnum: %d)\n", hm, hm->s->size, hm->s->bitnum);
data = get_data (hm);
- fprintf (stderr,"offset = %lx data = %p\n", (unsigned long) hm->s->data.offset, data);
+ fprintf (stderr, "offset = %lx data = %p\n",
+ (unsigned long)hm->s->data.offset, data);
#undef INDENT
#define INDENT " "
- for (size_t i = 0; i < hm->s->size; i++) {
- exp = get_expected_offset(hm, data[i].id);
- if (!SHMPTR_IS_NULL(data[i].p)) {
- PE("%2lu. (exp: %2lu w la %d) id %#-16lx p %#-14lx s %-7lu -- la %u ref %u %-16p\n",
- i, exp, data[exp].max_lookahead, data[i].id, data[i].p.offset, data[i].s,
- data[i].max_lookahead, data[i].refcnt, data + i);
- occ_num++;
+ for (size_t i = 0; i < hm->s->size; i++)
+ {
+ exp = get_expected_offset (hm, data[i].id);
+ if (!SHMPTR_IS_NULL (data[i].p))
+ {
+ PE ("%2lu. (exp: %2lu w la %d) id %#-16lx p %#-14lx s %-7lu -- la "
+ "%u ref %u %-16p\n",
+ i, exp, data[exp].max_lookahead, data[i].id, data[i].p.offset,
+ data[i].s, data[i].max_lookahead, data[i].refcnt, data + i);
+ occ_num++;
+ }
+ else
+ PE ("%2lu. empty -- la %u "
+ " %p\n",
+ i, data[i].max_lookahead, data + i);
}
- else
- PE("%2lu. empty -- la %u %p\n", i, data[i].max_lookahead,
- data + i);
-
- }
#undef INDENT
#define INDENT ""
- PE("occupancy: %lu %f\n", occ_num, ((double) occ_num)/hm->s->size);
+ PE ("occupancy: %lu %f\n", occ_num, ((double)occ_num) / hm->s->size);
}
size_t num_local_allocs;
- struct local_alloc {
+ struct local_alloc
+ {
void *base;
size_t size;
} allocs[];
static inline void *
map_memory (int fd, size_t size, off_t offset)
{
- void *ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
+ void *ret
+ = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
if (ret == MAP_FAILED)
{
- perror("mmap failed");
- exit(1);
+ perror ("mmap failed");
+ exit (1);
}
return ret;
}
static inline size_t
get_shared_memory_act_size (int nallocs)
{
- return sizeof(shared_memory_act) + nallocs*sizeof(struct local_alloc);
+ return sizeof (shared_memory_act) + nallocs * sizeof (struct local_alloc);
}
/* When the shared memory block is enlarged, we need to map it into
/* We need another entry in the alloc table. */
mem->num_local_allocs++;
newmem = realloc (mem, get_shared_memory_act_size (mem->num_local_allocs));
- newmem->allocs[newmem->num_local_allocs - 1]
- = ((struct local_alloc)
- {.base = map_memory (newmem->meta->fd, newmem->meta->size, 0),
- .size = newmem->meta->size});
+ newmem->allocs[newmem->num_local_allocs - 1] = ((struct local_alloc){
+ .base = map_memory (newmem->meta->fd, newmem->meta->size, 0),
+ .size = newmem->meta->size });
newmem->last_seen_size = newmem->meta->size;
return newmem;
}
shared_mem_ptr
shared_memory_get_mem_with_alignment (shared_memory_act **pmem, size_t size,
- size_t align)
+ size_t align)
{
shared_memory_act *mem = *pmem;
size_t new_size;
if (used_wa + size <= mem->meta->size)
{
- memset(last_base(mem) + mem->meta->used, 0xCA, used_wa - mem->meta->used);
- memset(last_base(mem) + used_wa, 0x42, size);
+ memset (last_base (mem) + mem->meta->used, 0xCA,
+ used_wa - mem->meta->used);
+ memset (last_base (mem) + used_wa, 0x42, size);
mem->meta->used = used_wa + size;
- return (shared_mem_ptr) {.offset = used_wa};
+ return (shared_mem_ptr){ .offset = used_wa };
}
/* We need to enlarge the memory segment. Double the size if that
is big enough, otherwise get what's needed. */
-
+
if (mem->meta->size * 2 > used_wa + size)
new_size = mem->meta->size * 2;
else
new_size = round_to_pagesize (used_wa + size);
-
+
orig_used = mem->meta->used;
mem->meta->size = new_size;
mem->meta->used = used_wa + size;
mem = new_base_mapping (mem);
*pmem = mem;
- assert(used_wa != 0);
+ assert (used_wa != 0);
- memset(last_base(mem) + orig_used, 0xCA, used_wa - orig_used);
- memset(last_base(mem) + used_wa, 0x42, size);
+ memset (last_base (mem) + orig_used, 0xCA, used_wa - orig_used);
+ memset (last_base (mem) + used_wa, 0x42, size);
- return (shared_mem_ptr) {.offset = used_wa};
+ return (shared_mem_ptr){ .offset = used_wa };
}
/* If another image changed the size, update the size accordingly. */
-void
+void
shared_memory_prepare (shared_memory_act **pmem)
{
shared_memory_act *mem = *pmem;
if (mem->meta->size == mem->last_seen_size)
return;
- mem = new_base_mapping(mem);
+ mem = new_base_mapping (mem);
*pmem = mem;
}
int fd;
size_t initial_size = round_to_pagesize (sizeof (global_shared_memory_meta));
- mem = malloc (get_shared_memory_act_size(1));
- fd = get_shmem_fd();
+ mem = malloc (get_shared_memory_act_size (1));
+ fd = get_shmem_fd ();
- ftruncate(fd, initial_size);
+ ftruncate (fd, initial_size);
mem->meta = map_memory (fd, initial_size, 0);
- *mem->meta = ((global_shared_memory_meta) {.size = initial_size,
- .used = sizeof(global_shared_memory_meta),
- .fd = fd});
+ *mem->meta = ((global_shared_memory_meta){
+ .size = initial_size,
+ .used = sizeof (global_shared_memory_meta),
+ .fd = fd });
mem->last_seen_size = initial_size;
mem->num_local_allocs = 1;
- mem->allocs[0] = ((struct local_alloc) {.base = mem->meta,
- .size = initial_size});
-
+ mem->allocs[0]
+ = ((struct local_alloc){ .base = mem->meta, .size = initial_size });
+
*pmem = mem;
}
memory block) to a pointer. */
void *
-shared_mem_ptr_to_void_ptr(shared_memory_act **pmem, shared_mem_ptr smp)
+shared_mem_ptr_to_void_ptr (shared_memory_act **pmem, shared_mem_ptr smp)
{
- return last_base(*pmem) + smp.offset;
+ return last_base (*pmem) + smp.offset;
}
-
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
-
#include "libgfortran.h"
#include "libcoarraynative.h"
static void
sync_all_init (counter_barrier *b)
{
- master_bind_active_image_barrier(this_image.m, b);
+ master_bind_active_image_barrier (this_image.m, b);
}
static inline void
static inline void
wait_table_cond (sync_iface *si, pthread_cond_t *cond)
{
- pthread_cond_wait (cond,&si->cis->table_lock);
+ pthread_cond_wait (cond, &si->cis->table_lock);
}
static int *
-get_locked_table(sync_iface *si) {
- lock_table(si);
+get_locked_table (sync_iface *si)
+{
+ lock_table (si);
return si->table;
}
void
sync_iface_init (sync_iface *si, alloc_iface *ai, shared_memory *sm)
{
- si->cis = SHMPTR_AS (sync_iface_shared *,
- shared_malloc (get_allocator(ai),
- sizeof(collsub_iface_shared)),
- sm);
+ si->cis = SHMPTR_AS (
+ sync_iface_shared *,
+ shared_malloc (get_allocator (ai), sizeof (collsub_iface_shared)), sm);
sync_all_init (&si->cis->sync_all);
initialize_shared_mutex (&si->cis->table_lock);
si->sm = sm;
- si->a = get_allocator(ai);
+ si->a = get_allocator (ai);
- si->cis->table =
- shared_malloc(si->a, sizeof(int)*local->total_num_images * local->total_num_images);
- si->cis->triggers =
- shared_malloc(si->a, sizeof(pthread_cond_t)*local->total_num_images);
+ si->cis->table = shared_malloc (si->a, sizeof (int) * local->total_num_images
+ * local->total_num_images);
+ si->cis->triggers = shared_malloc (si->a, sizeof (pthread_cond_t)
+ * local->total_num_images);
- si->table = SHMPTR_AS(int *, si->cis->table, si->sm);
- si->triggers = SHMPTR_AS(pthread_cond_t *, si->cis->triggers, si->sm);
+ si->table = SHMPTR_AS (int *, si->cis->table, si->sm);
+ si->triggers = SHMPTR_AS (pthread_cond_t *, si->cis->triggers, si->sm);
for (int i = 0; i < local->total_num_images; i++)
initialize_shared_condition (&si->triggers[i]);
sync_table (sync_iface *si, int *images, size_t size)
{
#if defined(DEBUG_NATIVE_COARRAY) && DEBUG_NATIVE_COARRAY
- dprintf (2, "Image %d waiting for these %ld images: ", this_image.image_num + 1, size);
- for (int d_i = 0; (size_t) d_i < size; d_i++)
+ dprintf (2,
+ "Image %d waiting for these %ld images: ", this_image.image_num + 1,
+ size);
+ for (int d_i = 0; (size_t)d_i < size; d_i++)
dprintf (2, "%d ", images[d_i]);
dprintf (2, "\n");
#endif
size_t i;
int done;
- int *table = get_locked_table(si);
+ int *table = get_locked_table (si);
for (i = 0; i < size; i++)
{
- table[images[i] - 1 + local->total_num_images*this_image.image_num]++;
+ table[images[i] - 1 + local->total_num_images * this_image.image_num]++;
pthread_cond_signal (&si->triggers[images[i] - 1]);
}
for (;;)
{
done = 1;
for (i = 0; i < size; i++)
- done &= si->table[images[i] - 1 + this_image.image_num*local->total_num_images]
- == si->table[this_image.image_num + (images[i] - 1)*local->total_num_images];
+ done &= si->table[images[i] - 1
+ + this_image.image_num * local->total_num_images]
+ == si->table[this_image.image_num
+ + (images[i] - 1) * local->total_num_images];
if (done)
break;
wait_table_cond (si, &si->triggers[this_image.image_num]);
void
sync_all (sync_iface *si)
{
- counter_barrier_wait(&si->cis->sync_all);
+ counter_barrier_wait (&si->cis->sync_all);
}
#include <assert.h>
/* Shared Memory objects live in their own namspace (usually found under
- * /dev/shm/), so the "/" is needed. It is for some reason impossible to create
- * a shared memory object without name. */
+ * /dev/shm/), so the "/" is needed. It is for some reason impossible to
+ * create a shared memory object without name. */
#define MEMOBJ_NAME "/gfortran_coarray_memfd"
size_t
-alignto(size_t size, size_t align) {
- return align*((size + align - 1)/align);
+alignto (size_t size, size_t align)
+{
+ return align * ((size + align - 1) / align);
}
size_t pagesize;
size_t
-round_to_pagesize(size_t s) {
- return alignto(s, pagesize);
+round_to_pagesize (size_t s)
+{
+ return alignto (s, pagesize);
}
size_t
-next_power_of_two(size_t size) {
- assert(size);
- return 1 << (PTR_BITS - __builtin_clzl(size-1));
+next_power_of_two (size_t size)
+{
+ assert (size);
+ return 1 << (PTR_BITS - __builtin_clzl (size - 1));
}
void
int
get_shmem_fd (void)
{
- char buffer[1<<10];
+ char buffer[1 << 10];
int fd, id;
id = random ();
do
{
- snprintf (buffer, sizeof (buffer),
- MEMOBJ_NAME "_%u_%d", (unsigned int) getpid (), id++);
+ snprintf (buffer, sizeof (buffer), MEMOBJ_NAME "_%u_%d",
+ (unsigned int)getpid (), id++);
fd = shm_open (buffer, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
}
while (fd == -1);
}
bool
-pack_array_prepare (pack_info * restrict pi, const gfc_array_char * restrict source)
+pack_array_prepare (pack_info *restrict pi,
+ const gfc_array_char *restrict source)
{
index_type dim;
bool packed;
span = source->span != 0 ? source->span : type_size;
for (index_type n = 0; n < dim; n++)
{
- pi->stride[n] = GFC_DESCRIPTOR_STRIDE (source,n) * span;
- pi->extent[n] = GFC_DESCRIPTOR_EXTENT (source,n);
+ pi->stride[n] = GFC_DESCRIPTOR_STRIDE (source, n) * span;
+ pi->extent[n] = GFC_DESCRIPTOR_EXTENT (source, n);
if (pi->extent[n] <= 0)
- {
- /* Do nothing. */
- packed = 1;
+ {
+ /* Do nothing. */
+ packed = 1;
pi->num_elem = 0;
- break;
- }
+ break;
+ }
if (ssize != pi->stride[n])
- packed = 0;
+ packed = 0;
pi->num_elem *= pi->extent[n];
ssize *= pi->extent[n];
}
void
-pack_array_finish (pack_info * const restrict pi, const gfc_array_char * const restrict source,
- char * restrict dest)
+pack_array_finish (pack_info *const restrict pi,
+ const gfc_array_char *const restrict source,
+ char *restrict dest)
{
index_type dim;
const char *restrict src;
while (src)
{
/* Copy the data. */
- memcpy(dest, src, size);
+ memcpy (dest, src, size);
/* Advance to the next element. */
dest += size;
src += stride0;
/* Advance to the next source element. */
index_type n = 0;
while (count[n] == pi->extent[n])
- {
- /* When we get to the end of a dimension, reset it and increment
- the next dimension. */
- count[n] = 0;
- /* We could precalculate these products, but this is a less
- frequently used path so probably not worth it. */
- src -= pi->stride[n] * pi->extent[n];
- n++;
- if (n == dim)
- {
- src = NULL;
- break;
- }
- else
- {
- count[n]++;
- src += pi->stride[n];
- }
- }
+ {
+ /* When we get to the end of a dimension, reset it and increment
+ the next dimension. */
+ count[n] = 0;
+ /* We could precalculate these products, but this is a less
+ frequently used path so probably not worth it. */
+ src -= pi->stride[n] * pi->extent[n];
+ n++;
+ if (n == dim)
+ {
+ src = NULL;
+ break;
+ }
+ else
+ {
+ count[n]++;
+ src += pi->stride[n];
+ }
+ }
}
}
void
-unpack_array_finish (pack_info * const restrict pi,
- const gfc_array_char * restrict d,
+unpack_array_finish (pack_info *const restrict pi,
+ const gfc_array_char *restrict d,
const char *restrict src)
{
index_type stride0;
- char * restrict dest;
+ char *restrict dest;
index_type size;
index_type count[GFC_MAX_DIMENSIONS];
index_type dim;
dest = d->base_addr;
dim = GFC_DESCRIPTOR_RANK (d);
-
- memset(count, '\0', sizeof(count) * dim);
+ memset (count, '\0', sizeof (count) * dim);
while (dest)
{
memcpy (dest, src, size);
}
else
{
- count[n] ++;
+ count[n]++;
dest += pi->stride[n];
}
}
static inline int
div_ru (int divident, int divisor)
{
- return (divident + divisor - 1)/divisor;
+ return (divident + divisor - 1) / divisor;
}
/* Need to keep this in sync with
trans-array.h:gfc_coarray_allocation_type. */
-enum gfc_coarray_allocation_type {
+enum gfc_coarray_allocation_type
+{
GFC_NCA_NORMAL_COARRAY = 1,
GFC_NCA_LOCK_COARRAY,
GFC_NCA_EVENT_COARRAY,
void cas_coarray_alloc (gfc_array_void *, int, int, int);
export_proto (cas_coarray_alloc);
-void
-cas_coarray_free (gfc_array_void *, int);
+void cas_coarray_free (gfc_array_void *, int);
export_proto (cas_coarray_free);
int cas_coarray_this_image (int);
void cas_coarray_sync_all (int *);
export_proto (cas_coarray_sync_all);
-void cas_sync_images (size_t, int *, int*, char *, size_t);
+void cas_sync_images (size_t, int *, int *, char *, size_t);
export_proto (cas_sync_images);
void cas_lock (void *);
export_proto (cas_unlock);
void cas_collsub_reduce_array (gfc_array_char *, void (*) (void *, void *),
- int *, int*, char *, size_t);
+ int *, int *, char *, size_t);
export_proto (cas_collsub_reduce_array);
void cas_collsub_reduce_scalar (void *, index_type, void (*) (void *, void *),
- int *, int*, char *, size_t);
+ int *, int *, char *, size_t);
export_proto (cas_collsub_reduce_scalar);
-void cas_collsub_broadcast_array (gfc_array_char * restrict, int, int *, char *,
- size_t);
+void cas_collsub_broadcast_array (gfc_array_char *restrict, int, int *, char *,
+ size_t);
export_proto (cas_collsub_broadcast_array);
-void cas_collsub_broadcast_scalar (void * restrict, size_t, int, int *, char *,
- size_t);
-export_proto(cas_collsub_broadcast_scalar);
+void cas_collsub_broadcast_scalar (void *restrict, size_t, int, int *, char *,
+ size_t);
+export_proto (cas_collsub_broadcast_scalar);
void
cas_coarray_alloc (gfc_array_void *desc, int elem_size, int corank,
size_t last_lbound;
size_t size_in_bytes;
- ensure_initialization(); /* This function might be the first one to be
- called, if it is called in a constructor. */
+ ensure_initialization (); /* This function might be the first one to be
+ called, if it is called in a constructor. */
if (alloc_type == GFC_NCA_LOCK_COARRAY)
elem_size = sizeof (pthread_mutex_t);
else if (alloc_type == GFC_NCA_EVENT_COARRAY)
- elem_size = sizeof(char); /* replace with proper type. */
+ elem_size = sizeof (char); /* replace with proper type. */
- last_rank_index = GFC_DESCRIPTOR_RANK(desc) + corank -1;
+ last_rank_index = GFC_DESCRIPTOR_RANK (desc) + corank - 1;
num_elems = 1;
num_coarray_elems = 1;
- for (i = 0; i < GFC_DESCRIPTOR_RANK(desc); i++)
- num_elems *= GFC_DESCRIPTOR_EXTENT(desc, i);
- for (i = GFC_DESCRIPTOR_RANK(desc); i < last_rank_index; i++)
+ for (i = 0; i < GFC_DESCRIPTOR_RANK (desc); i++)
+ num_elems *= GFC_DESCRIPTOR_EXTENT (desc, i);
+ for (i = GFC_DESCRIPTOR_RANK (desc); i < last_rank_index; i++)
{
- num_elems *= GFC_DESCRIPTOR_EXTENT(desc, i);
- num_coarray_elems *= GFC_DESCRIPTOR_EXTENT(desc, i);
+ num_elems *= GFC_DESCRIPTOR_EXTENT (desc, i);
+ num_coarray_elems *= GFC_DESCRIPTOR_EXTENT (desc, i);
}
extent_last_codimen = div_ru (local->total_num_images, num_coarray_elems);
- last_lbound = GFC_DIMENSION_LBOUND(desc->dim[last_rank_index]);
- GFC_DIMENSION_SET(desc->dim[last_rank_index], last_lbound,
- last_lbound + extent_last_codimen - 1,
- num_elems);
+ last_lbound = GFC_DIMENSION_LBOUND (desc->dim[last_rank_index]);
+ GFC_DIMENSION_SET (desc->dim[last_rank_index], last_lbound,
+ last_lbound + extent_last_codimen - 1, num_elems);
size_in_bytes = elem_size * num_elems * extent_last_codimen;
if (alloc_type == GFC_NCA_LOCK_COARRAY)
int expected = 0;
/* Allocate enough space for the metadata infront of the lock
array. */
- addr = get_memory_by_id_zero (&local->ai, size_in_bytes
- + sizeof (lock_array),
- (intptr_t) desc);
+ addr = get_memory_by_id_zero (
+ &local->ai, size_in_bytes + sizeof (lock_array), (intptr_t)desc);
/* Use of a traditional spin lock to avoid race conditions with
the initization of the mutex. We could alternatively put a
global lock around allocate, but that would probably be
slower. */
while (!__atomic_compare_exchange_n (&addr->owner, &expected,
- this_image.image_num + 1,
- false, __ATOMIC_SEQ_CST,
- __ATOMIC_SEQ_CST));
+ this_image.image_num + 1, false,
+ __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST))
+ ;
if (!addr->initialized++)
{
for (i = 0; i < local->total_num_images; i++)
desc->base_addr = &addr->arr;
}
else if (alloc_type == GFC_NCA_EVENT_COARRAY)
- (void) 0; // TODO
+ (void)0; // TODO
else
- desc->base_addr = get_memory_by_id (&local->ai, size_in_bytes,
- (intptr_t) desc);
+ desc->base_addr
+ = get_memory_by_id (&local->ai, size_in_bytes, (intptr_t)desc);
}
void
la = desc->base_addr - offsetof (lock_array, arr);
/* TODO: Fix this, replace with some kind of atomic initilization. */
while (!__atomic_compare_exchange_n (&la->owner, &expected,
- this_image.image_num+1,
- false, __ATOMIC_SEQ_CST,
- __ATOMIC_SEQ_CST));
+ this_image.image_num + 1, false,
+ __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST))
+ ;
if (!--la->initialized)
- {
+ {
/* Coarray locks can be removed and just normal
pthread_mutex can be used. */
- for (i = 0; i < local->total_num_images; i++)
- pthread_mutex_destroy (&la->arr[i]);
- }
+ for (i = 0; i < local->total_num_images; i++)
+ pthread_mutex_destroy (&la->arr[i]);
+ }
__atomic_store_n (&la->owner, 0, __ATOMIC_SEQ_CST);
}
else if (alloc_type == GFC_NCA_EVENT_COARRAY)
- (void) 0; //TODO
+ (void)0; // TODO
- free_memory_with_id (&local->ai, (intptr_t) desc);
+ free_memory_with_id (&local->ai, (intptr_t)desc);
desc->base_addr = NULL;
}
int
-cas_coarray_this_image (int distance __attribute__((unused)))
+cas_coarray_this_image (int distance __attribute__ ((unused)))
{
return this_image.image_num + 1;
}
int
-cas_coarray_num_images (int distance __attribute__((unused)))
+cas_coarray_num_images (int distance __attribute__ ((unused)))
{
return local->total_num_images;
}
void
cas_coarray_sync_all (int *stat)
{
- STAT_ERRMSG_ENTRY_CHECK(stat, NULL, 0);
+ STAT_ERRMSG_ENTRY_CHECK (stat, NULL, 0);
sync_all (&local->si);
}
void
-cas_sync_images (size_t s, int *images, int *stat, char *error, size_t err_size)
+cas_sync_images (size_t s, int *images, int *stat, char *error,
+ size_t err_size)
{
- STAT_ERRMSG_ENTRY_CHECK(stat, error, err_size);
+ STAT_ERRMSG_ENTRY_CHECK (stat, error, err_size);
sync_table (&local->si, images, s);
}
}
void
-cas_collsub_reduce_array (gfc_array_char *desc, void (*assign_function) (void *, void *),
- int *result_image, int *stat, char *errmsg, size_t errmsg_len)
+cas_collsub_reduce_array (gfc_array_char *desc,
+ void (*assign_function) (void *, void *),
+ int *result_image, int *stat, char *errmsg,
+ size_t errmsg_len)
{
- STAT_ERRMSG_ENTRY_CHECK(stat, errmsg, errmsg_len);
+ STAT_ERRMSG_ENTRY_CHECK (stat, errmsg, errmsg_len);
collsub_reduce_array (&local->ci, desc, result_image, assign_function);
}
void
cas_collsub_reduce_scalar (void *obj, index_type elem_size,
void (*assign_function) (void *, void *),
- int *result_image,
- int *stat, char *errmsg, size_t errmsg_len)
+ int *result_image, int *stat, char *errmsg,
+ size_t errmsg_len)
{
- STAT_ERRMSG_ENTRY_CHECK(stat, errmsg, errmsg_len);
- collsub_reduce_scalar (&local->ci, obj, elem_size, result_image, assign_function);
+ STAT_ERRMSG_ENTRY_CHECK (stat, errmsg, errmsg_len);
+ collsub_reduce_scalar (&local->ci, obj, elem_size, result_image,
+ assign_function);
}
void
-cas_collsub_broadcast_array (gfc_array_char * restrict a, int source_image,
- int *stat, char *errmsg, size_t errmsg_len)
+cas_collsub_broadcast_array (gfc_array_char *restrict a, int source_image,
+ int *stat, char *errmsg, size_t errmsg_len)
{
- STAT_ERRMSG_ENTRY_CHECK(stat, errmsg, errmsg_len);
+ STAT_ERRMSG_ENTRY_CHECK (stat, errmsg, errmsg_len);
collsub_broadcast_array (&local->ci, a, source_image - 1);
}
void
-cas_collsub_broadcast_scalar (void * restrict obj, size_t size, int source_image,
- int *stat, char *errmsg, size_t errmsg_len)
+cas_collsub_broadcast_scalar (void *restrict obj, size_t size,
+ int source_image, int *stat, char *errmsg,
+ size_t errmsg_len)
{
- STAT_ERRMSG_ENTRY_CHECK(stat, errmsg, errmsg_len);
+ STAT_ERRMSG_ENTRY_CHECK (stat, errmsg, errmsg_len);
collsub_broadcast_scalar (&local->ci, obj, size, source_image - 1);
}
projects / thirdparty / gcc.git / commitdiff
