#include <string.h>
#include "slotsmanager.h"
#include "partmanager.h"
#include "utils.h"

Include dependency graph for slotsmanager.c:

Macros
#define	SLOTS_ENABLED(ptype, sman) (sman->info[ptype].enabled)

#define	GARBAGE(i, ptype, pman, sman) (sman ? BASESLOT_PI(i,ptype, sman)->ReverseLink > pman->MaxPart : pman->Base[i].IsGarbage)

#define	PART(i, ptype, pman, sman) (sman ? (void ) BASESLOT_PI(i, ptype, sman) : (void ) &pman->Base[i])

Functions
static int	slots_gc_base (struct part_manager_type *pman)

static int	slots_gc_slots (int compact_slots, struct part_manager_type pman, struct slots_manager_type *sman)

static void	slots_connect_new_slot (int i, int pi, int type, struct part_manager_type pman, struct slots_manager_type sman)

int	slots_convert (int parent, int ptype, int placement, struct part_manager_type pman, struct slots_manager_type sman)

int	slots_split_particle (int parent, double childmass, struct part_manager_type *pman)

int	slots_gc (int compact_slots, struct part_manager_type pman, struct slots_manager_type *sman)

static int	slots_find_next_garbage (int start, int used, int ptype, struct part_manager_type pman, struct slots_manager_type sman)

static int	slots_find_next_nongarbage (int start, int used, int ptype, struct part_manager_type pman, struct slots_manager_type sman)

static int	slots_gc_compact (const int used, int ptype, struct part_manager_type pman, struct slots_manager_type sman)

static int	slot_cmp_reverse_link (const void b1in, const void b2in)

static int	slots_gc_mark (const struct part_manager_type pman, const struct slots_manager_type sman)

static int	slots_gc_sweep (int ptype, struct part_manager_type pman, struct slots_manager_type sman)

static void	slots_gc_collect (int ptype, struct part_manager_type pman, struct slots_manager_type sman)

static int	order_by_type_and_key (const void a, const void b)

int	slots_get_last_garbage (int nfirst, int nlast, int ptype, const struct part_manager_type pman, const struct slots_manager_type sman)

void	slots_gc_sorted (struct part_manager_type pman, struct slots_manager_type sman)

size_t	slots_reserve (int where, int64_t atleast[6], struct slots_manager_type *sman)

void	slots_init (double increase, struct slots_manager_type *sman)

void	slots_set_enabled (int ptype, size_t elsize, struct slots_manager_type *sman)

void	slots_free (struct slots_manager_type *sman)

void	slots_mark_garbage (int i, struct part_manager_type pman, struct slots_manager_type sman)

void	slots_check_id_consistency (struct part_manager_type pman, struct slots_manager_type sman)

void	slots_setup_topology (struct part_manager_type pman, int64_t NLocal, struct slots_manager_type *sman)

void	slots_setup_id (const struct part_manager_type pman, struct slots_manager_type sman)

Variables
struct slots_manager_type	SlotsManager [1]

MPI_Datatype	MPI_TYPE_PARTICLE = 0

MPI_Datatype	MPI_TYPE_PLAN_ENTRY = 0

MPI_Datatype	MPI_TYPE_SLOT [6] = {0}

static struct sph_particle_data *	GDB_SphP

static struct star_particle_data *	GDB_StarP

static struct bh_particle_data *	GDB_BhP

Macro Definition Documentation

◆ GARBAGE

#define GARBAGE	(	i,
		ptype,
		pman,
		sman
	)	(sman ? BASESLOT_PI(i,ptype, sman)->ReverseLink > pman->MaxPart : pman->Base[i].IsGarbage)

Definition at line 164 of file slotsmanager.c.

◆ PART

#define PART	(	i,
		ptype,
		pman,
		sman
	)	(sman ? (void ) BASESLOT_PI(i, ptype, sman) : (void ) &pman->Base[i])

Definition at line 165 of file slotsmanager.c.

◆ SLOTS_ENABLED

#define SLOTS_ENABLED	(	ptype,
		sman
	)	(sman->info[ptype].enabled)

Definition at line 9 of file slotsmanager.c.

Function Documentation

◆ order_by_type_and_key()

static int order_by_type_and_key	(	const void *	a,
		const void *	b
	)

static

Definition at line 388 of file slotsmanager.c.

 {
     const struct particle_data * pa  = (const struct particle_data *) a;
     const struct particle_data * pb  = (const struct particle_data *) b;
  
     if(pa->IsGarbage && !pb->IsGarbage)
         return +1;
     if(!pa->IsGarbage && pb->IsGarbage)
         return -1;
     if(pa->Type < pb->Type)
         return -1;
     if(pa->Type > pb->Type)
         return +1;
     if(pa->Key < pb->Key)
         return -1;
     if(pa->Key > pb->Key)
         return +1;
  
     return 0;
 }

References particle_data::IsGarbage, particle_data::Key, and particle_data::Type.

Referenced by slots_gc_sorted().

Here is the caller graph for this function:

◆ slot_cmp_reverse_link()

static int slot_cmp_reverse_link	(	const void *	b1in,
		const void *	b2in
	)

static

Definition at line 255 of file slotsmanager.c.

                                                                        {
     const struct particle_data_ext * b1 = (struct particle_data_ext *) b1in;
     const struct particle_data_ext * b2 = (struct particle_data_ext *) b2in;
     return (b1->ReverseLink > b2->ReverseLink) - (b1->ReverseLink < b2->ReverseLink);
 }

References particle_data_ext::ReverseLink.

Referenced by slots_gc_sorted().

Here is the caller graph for this function:

◆ slots_check_id_consistency()

void slots_check_id_consistency	(	struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

Definition at line 587 of file slotsmanager.c.

 {
     int64_t used[6] = {0};
     int64_t i;
  
     for(i = 0; i < pman->NumPart; i++) {
         int type = pman->Base[i].Type;
         if(pman->Base[i].IsGarbage)
             continue;
         struct slot_info info = sman->info[type];
         if(!info.enabled)
             continue;
  
         int PI = pman->Base[i].PI;
         if(PI >= info.size) {
             endrun(1, "slot PI consistency failed2\n");
         }
         if(BASESLOT_PI(PI, type, sman)->ID != pman->Base[i].ID) {
             endrun(1, "slot id consistency failed2: i=%d PI=%d type = %d P.ID = %ld SLOT.ID=%ld\n",i, PI, pman->Base[i].Type, pman->Base[i].ID, BASESLOT_PI(PI, type, sman)->ID);
         }
         used[type] ++;
     }
     int64_t NTotal[6];
  
     MPI_Allreduce(used, NTotal, 6, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
  
     int ptype;
     for(ptype = 0; ptype < 6; ptype ++) {
         if(NTotal[ptype] > 0) {
             /* Watch out: we print per rank here, but the condition must be global*/
             message(0, "Task 0: GC: Used slots for type %d is %ld\n", ptype, used[ptype]);
         }
     }
 }

References part_manager_type::Base, BASESLOT_PI, slot_info::enabled, endrun(), particle_data::ID, slots_manager_type::info, particle_data::IsGarbage, message(), MPI_INT64, part_manager_type::NumPart, particle_data::PI, ptype, slot_info::size, and particle_data::Type.

Referenced by domain_exchange_once(), slots_gc_slots(), slots_gc_sorted(), test_exchange(), test_exchange_uneven(), test_exchange_with_garbage(), test_exchange_zero_slots(), test_slots_gc(), and test_slots_gc_sorted().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_connect_new_slot()

static void slots_connect_new_slot	(	int	i,
		int	pi,
		int	type,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 29 of file slotsmanager.c.

 {
     /* Fill slot with a meaningless
      * poison value ('e') so we will recognise
      * if it is uninitialised.*/
     memset(BASESLOT_PI(pi, type, sman), 101, sman->info[type].elsize);
     /* book keeping ID: debug only */
     BASESLOT_PI(pi, type, sman)->ID = pman->Base[i].ID;
     /*Update the particle's pointer*/
     pman->Base[i].PI = pi;
 }

References part_manager_type::Base, BASESLOT_PI, slot_info::elsize, particle_data::ID, slots_manager_type::info, and particle_data::PI.

Referenced by slots_convert().

Here is the caller graph for this function:

◆ slots_convert()

int slots_convert	(	int	parent,
		int	ptype,
		int	placement,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

Definition at line 60 of file slotsmanager.c.

 {
     /*Explicitly mark old slot as garbage*/
     int oldtype = pman->Base[parent].Type;
     int oldPI = pman->Base[parent].PI;
     if(oldPI >= 0 && SLOTS_ENABLED(oldtype, sman))
         BASESLOT_PI(oldPI, oldtype, sman)->ReverseLink = pman->MaxPart + 100;
  
     /*Make a new slot*/
     if(SLOTS_ENABLED(ptype, sman)) {
         int newPI = placement;
         /* if enabled, alloc a new Slot for secondary data */
         if(placement < 0)
             newPI = atomic_fetch_and_add_64(&sman->info[ptype].size, 1);
  
         /* There is no way clearly to safely grow the slots during this, because the memory may be deep in the heap.*/
         if(newPI >= sman->info[ptype].maxsize) {
             endrun(1, "Tried to use non-allocated slot %d (> %d)\n", newPI, sman->info[ptype].maxsize);
         }
         slots_connect_new_slot(parent, newPI, ptype, pman, sman);
     }
     /*Type changed after slot updated*/
     pman->Base[parent].Type = ptype;
     return parent;
 }

References atomic_fetch_and_add_64(), part_manager_type::Base, BASESLOT_PI, endrun(), slots_manager_type::info, part_manager_type::MaxPart, slot_info::maxsize, particle_data::PI, ptype, slot_info::size, slots_connect_new_slot(), SLOTS_ENABLED, and particle_data::Type.

Referenced by blackhole_make_one(), make_particle_star(), test_slots_convert(), and test_slots_fork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_find_next_garbage()

static int slots_find_next_garbage	(	int	start,
		int	used,
		int	ptype,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 169 of file slotsmanager.c.

 {
     int i, nextgc = used;
     /*Find another garbage particle*/
     for(i = start; i < used; i++)
         if(GARBAGE(i, ptype, pman, sman)) {
             nextgc = i;
             break;
         }
     return nextgc;
 }

References GARBAGE, and ptype.

Referenced by slots_gc_compact().

Here is the caller graph for this function:

◆ slots_find_next_nongarbage()

static int slots_find_next_nongarbage	(	int	start,
		int	used,
		int	ptype,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 183 of file slotsmanager.c.

 {
     int i, nextgc = used;
     /*Find another garbage particle*/
     for(i = start; i < used; i++)
         if(!GARBAGE(i, ptype, pman, sman)) {
             nextgc = i;
             break;
         }
     return nextgc;
 }

References GARBAGE, and ptype.

Referenced by slots_gc_compact().

Here is the caller graph for this function:

◆ slots_free()

void slots_free ( struct slots_manager_type * sman )

Definition at line 570 of file slotsmanager.c.

 {
     myfree(sman->Base);
 }

References slots_manager_type::Base, and myfree.

Referenced by teardown_particles().

Here is the caller graph for this function:

◆ slots_gc()

int slots_gc	(	int *	compact_slots,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

Definition at line 145 of file slotsmanager.c.

 {
     /* tree is invalidated if the sequence on P is reordered; */
  
     int tree_invalid = 0;
  
     /* TODO: in principle we can track this change and modify the tree nodes;
      * But doing so requires cleaning up the TimeBin link lists, and the tree
      * link lists first. likely worth it, since GC happens only in domain decompose
      * and snapshot IO, both take far more time than rebuilding the tree. */
     tree_invalid |= slots_gc_base(pman);
     tree_invalid |= slots_gc_slots(compact_slots, pman, sman);
  
     MPI_Allreduce(MPI_IN_PLACE, &tree_invalid, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
  
     return tree_invalid;
 }

References slots_gc_base(), and slots_gc_slots().

Referenced by domain_exchange_once(), run(), test_slots_gc(), and test_slots_zero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_base()

static int slots_gc_base ( struct part_manager_type * pman )

static

Definition at line 234 of file slotsmanager.c.

 {
     int64_t total0, total;
  
     MPI_Allreduce(&pman->NumPart, &total0, 1, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
  
     /*Compactify the P array: this invalidates the ReverseLink, so
         * that ReverseLink is valid only within gc.*/
     int64_t ngc = slots_gc_compact(pman->NumPart, -1, pman, NULL);
  
     pman->NumPart -= ngc;
  
     MPI_Allreduce(&pman->NumPart, &total, 1, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
  
     if(total != total0) {
         message(0, "GC : Reducing Particle slots from %ld to %ld\n", total0, total);
         return 1;
     }
     return 0;
 }

References message(), MPI_INT64, part_manager_type::NumPart, and slots_gc_compact().

Referenced by slots_gc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_collect()

static void slots_gc_collect	(	int	ptype,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 322 of file slotsmanager.c.

 {
     int64_t i;
     if(!SLOTS_ENABLED(ptype, sman)) return;
  
     /* Now update the link in BhP */
 #pragma omp parallel for
     for(i = 0;
         i < sman->info[ptype].size;
         i ++) {
  
 #ifdef DEBUG
         if(BASESLOT_PI(i, ptype, sman)->ReverseLink >= pman->MaxPart) {
             endrun(1, "Shall not happen: i=%d ptype = %d\n", i,ptype);
         }
 #endif
  
         pman->Base[BASESLOT_PI(i, ptype, sman)->ReverseLink].PI = i;
     }
 }

References part_manager_type::Base, BASESLOT_PI, endrun(), slots_manager_type::info, part_manager_type::MaxPart, particle_data::PI, ptype, particle_data_ext::ReverseLink, slot_info::size, and SLOTS_ENABLED.

Referenced by slots_gc_slots(), and slots_gc_sorted().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_compact()

static int slots_gc_compact	(	const int	used,
		int	ptype,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 197 of file slotsmanager.c.

 {
     /*Find first garbage particle: can't use bisection here as not sorted.*/
     int nextgc = slots_find_next_garbage(0, used, ptype, pman, sman);
     size_t size = sizeof(struct particle_data);
     if(sman)
         size = sman->info[ptype].elsize;
     int ngc = 0;
     /*Note each particle is tested exactly once*/
     while(nextgc < used) {
         /*Now lastgc contains a garbage*/
         int lastgc = nextgc;
         /*Find a non-garbage after it*/
         int src = slots_find_next_nongarbage(lastgc+1, used, ptype, pman, sman);
         /*If no more non-garbage particles, don't bother copying, just add a skip*/
         if(src == used) {
             ngc += src - lastgc;
             break;
         }
         /*Destination is shifted already*/
         int dest = lastgc - ngc;
  
         /*Find another garbage particle*/
         nextgc = slots_find_next_garbage(src + 1, used, ptype, pman, sman);
  
         /*Add number of particles we skipped*/
         ngc += src - lastgc;
         int nmove = nextgc - src +1;
 //         message(1,"i = %d, PI = %d-> %d, nm=%d\n",i, src, dest, nmove);
         memmove(PART(dest, ptype, pman, sman),PART(src, ptype, pman, sman),nmove*size);
     }
     if(ngc > used)
         endrun(1, "ngc = %d > used = %d!\n", ngc, used);
     return ngc;
 }

References slot_info::elsize, endrun(), slots_manager_type::info, PART, ptype, slots_find_next_garbage(), and slots_find_next_nongarbage().

Referenced by slots_gc_base(), and slots_gc_sweep().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_mark()

static int slots_gc_mark	(	const struct part_manager_type *	pman,
		const struct slots_manager_type *	sman
	)

static

Definition at line 262 of file slotsmanager.c.

 {
     int64_t i;
     if(!(sman->info[0].enabled ||
        sman->info[1].enabled ||
        sman->info[2].enabled ||
        sman->info[3].enabled ||
        sman->info[4].enabled ||
        sman->info[5].enabled))
         return 0;
  
 #ifdef DEBUG
     int ptype;
     /*Initially set all reverse links to an obviously invalid value*/
     for(ptype = 0; ptype < 6; ptype++)
     {
         struct slot_info info = sman->info[ptype];
         if(!info.enabled)
             continue;
         #pragma omp parallel for
         for(i = 0; i < info.size; i++) {
             struct particle_data_ext * sdata = (struct particle_data_ext * )(info.ptr + info.elsize * i);
             sdata->ReverseLink = pman->MaxPart + 100;
         }
     }
 #endif
  
 #pragma omp parallel for
     for(i = 0; i < pman->NumPart; i++) {
         struct slot_info info = sman->info[pman->Base[i].Type];
         if(!info.enabled)
             continue;
         int sind = pman->Base[i].PI;
         if(sind >= info.size || sind < 0)
             endrun(1, "Particle %d, type %d has PI index %d beyond max slot size %d.\n", i, pman->Base[i].Type, sind, info.size);
         struct particle_data_ext * sdata = (struct particle_data_ext * )(info.ptr + info.elsize * sind);
         sdata->ReverseLink = i;
         /* Make the PI of garbage particles invalid*/
         if(pman->Base[i].IsGarbage)
             sdata->ReverseLink = pman->MaxPart + 100;
     }
     return 0;
 }

References part_manager_type::Base, slot_info::elsize, slot_info::enabled, endrun(), slots_manager_type::info, particle_data::IsGarbage, part_manager_type::MaxPart, part_manager_type::NumPart, particle_data::PI, slot_info::ptr, ptype, particle_data_ext::ReverseLink, slot_info::size, and particle_data::Type.

Referenced by slots_gc_slots(), and slots_gc_sorted().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_slots()

static int slots_gc_slots	(	int *	compact_slots,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 345 of file slotsmanager.c.

 {
     int ptype;
  
     int64_t total0[6];
     int64_t total1[6];
  
     int disabled = 1;
     for(ptype = 0; ptype < 6; ptype ++) {
         MPI_Allreduce(&sman->info[ptype].size, &total0[ptype], 1, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
         if(compact_slots[ptype])
             disabled = 0;
     }
  
 #ifdef DEBUG
     slots_check_id_consistency(pman, sman);
 #endif
  
     if(!disabled) {
         slots_gc_mark(pman, sman);
  
         for(ptype = 0; ptype < 6; ptype++) {
             if(!compact_slots[ptype])
                 continue;
             slots_gc_sweep(ptype, pman, sman);
             slots_gc_collect(ptype, pman, sman);
         }
     }
 #ifdef DEBUG
     slots_check_id_consistency(pman, sman);
 #endif
     for(ptype = 0; ptype < 6; ptype ++) {
         MPI_Allreduce(&sman->info[ptype].size, &total1[ptype], 1, MPI_INT64, MPI_SUM, MPI_COMM_WORLD);
  
         if(total1[ptype] != total0[ptype])
             message(0, "GC: Reducing number of slots for %d from %ld to %ld\n", ptype, total0[ptype], total1[ptype]);
     }
  
     /* slot gc never invalidates the tree */
     return 0;
 }

References slots_manager_type::info, message(), MPI_INT64, ptype, slot_info::size, slots_check_id_consistency(), slots_gc_collect(), slots_gc_mark(), and slots_gc_sweep().

Referenced by slots_gc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_sorted()

void slots_gc_sorted	(	struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

Definition at line 442 of file slotsmanager.c.

 {
     int ptype;
     /* Resort the particles such that those of the same type and key are close by.
      * The locality is broken by the exchange. */
     qsort_openmp(pman->Base, pman->NumPart, sizeof(struct particle_data), order_by_type_and_key);
  
     /*Remove garbage particles*/
     pman->NumPart = slots_get_last_garbage(0, pman->NumPart -1 , -1, pman, NULL);
  
     /*Set up ReverseLink*/
     slots_gc_mark(pman, sman);
  
     for(ptype = 0; ptype < 6; ptype++) {
         if(!SLOTS_ENABLED(ptype, sman))
             continue;
         /* sort the used ones
          * by their location in the P array */
         qsort_openmp(sman->info[ptype].ptr,
                  sman->info[ptype].size,
                  sman->info[ptype].elsize,
                  slot_cmp_reverse_link);
  
         /*Reduce slots used*/
         SlotsManager->info[ptype].size = slots_get_last_garbage(0, sman->info[ptype].size-1, ptype, pman, sman);
         slots_gc_collect(ptype, pman, sman);
     }
 #ifdef DEBUG
     slots_check_id_consistency(pman, sman);
 #endif
 }

References part_manager_type::Base, slot_info::elsize, slots_manager_type::info, part_manager_type::NumPart, order_by_type_and_key(), slot_info::ptr, ptype, qsort_openmp, slot_info::size, slot_cmp_reverse_link(), slots_check_id_consistency(), SLOTS_ENABLED, slots_gc_collect(), slots_gc_mark(), slots_get_last_garbage(), and SlotsManager.

Referenced by domain_decompose_full(), test_slots_gc_sorted(), and test_slots_zero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_gc_sweep()

static int slots_gc_sweep	(	int	ptype,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

static

Definition at line 308 of file slotsmanager.c.

 {
     if(!SLOTS_ENABLED(ptype, sman)) return 0;
     int64_t used = sman->info[ptype].size;
  
     int64_t ngc = slots_gc_compact(used, ptype, pman, sman);
  
     sman->info[ptype].size -= ngc;
  
     return ngc;
 }

References slots_manager_type::info, ptype, slot_info::size, SLOTS_ENABLED, and slots_gc_compact().

Referenced by slots_gc_slots().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_get_last_garbage()

int slots_get_last_garbage	(	int	nfirst,
		int	nlast,
		int	ptype,
		const struct part_manager_type *	pman,
		const struct slots_manager_type *	sman
	)

Definition at line 414 of file slotsmanager.c.

 {
     /* Enforce that we don't get a negative number for an empty array*/
     if(nlast < 0)
         return 0;
     /* nfirst is always not garbage, nlast is always garbage*/
     if(GARBAGE(nfirst, ptype, pman, sman))
         return nfirst;
     if(!GARBAGE(nlast, ptype, pman, sman))
         return nlast+1;
     /*Bisection*/
     do {
         int nmid = (nfirst + nlast)/2;
         if(GARBAGE(nmid, ptype, pman, sman))
             nlast = nmid;
         else
             nfirst = nmid;
     }
     while(nlast - nfirst > 1);
  
     return nlast;
 }

References GARBAGE, and ptype.

Referenced by slots_gc_sorted().

Here is the caller graph for this function:

◆ slots_init()

void slots_init	(	double	increase,
		struct slots_manager_type *	sman
	)

Definition at line 550 of file slotsmanager.c.

 {
     memset(sman, 0, sizeof(sman[0]));
  
     MPI_Type_contiguous(sizeof(struct particle_data), MPI_BYTE, &MPI_TYPE_PARTICLE);
     MPI_Type_commit(&MPI_TYPE_PARTICLE);
     sman->increase = increase;
 }

References slots_manager_type::increase, and MPI_TYPE_PARTICLE.

Referenced by begrun(), setup_density(), and setup_particles().

Here is the caller graph for this function:

◆ slots_mark_garbage()

void slots_mark_garbage	(	int	i,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

Definition at line 577 of file slotsmanager.c.

 {
     pman->Base[i].IsGarbage = 1;
     int type = pman->Base[i].Type;
     if(SLOTS_ENABLED(type, sman)) {
         BASESLOT_PI(pman->Base[i].PI, type, sman)->ReverseLink = pman->MaxPart + 100;
     }
 }

References part_manager_type::Base, BASESLOT_PI, particle_data::IsGarbage, part_manager_type::MaxPart, particle_data::PI, SLOTS_ENABLED, and particle_data::Type.

Referenced by blackhole_feedback_ngbiter(), domain_exchange_once(), test_exchange_with_garbage(), test_slots_gc(), test_slots_gc_sorted(), and test_slots_zero().

Here is the caller graph for this function:

◆ slots_reserve()

size_t slots_reserve	(	int	where,
		int64_t	atleast[6],
		struct slots_manager_type *	sman
	)

Definition at line 475 of file slotsmanager.c.

 {
     int64_t newMaxSlots[6];
     int ptype;
     int good = 1;
  
     if(sman->Base == NULL) {
         sman->Base = (char*) mymalloc("SlotsBase", sizeof(struct sph_particle_data));
         /* This is so the ptr is never null! Avoid undefined behaviour. */
         for(ptype = 5; ptype >= 0; ptype--) {
             sman->info[ptype].ptr = sman->Base;
         }
     }
  
     int64_t add = sman->increase;
     if (add < 8192) add = 8192;
  
     /* FIXME: allow shrinking; need to tweak the memmove later. */
     for(ptype = 0; ptype < 6; ptype ++) {
         newMaxSlots[ptype] = sman->info[ptype].maxsize;
         if(!SLOTS_ENABLED(ptype, sman)) continue;
         /* if current empty slots is less than half of add, need to grow */
         if (newMaxSlots[ptype] <= atleast[ptype] + add / 2) {
             newMaxSlots[ptype] = atleast[ptype] + add;
             good = 0;
         }
     }
  
     size_t total_bytes = 0;
     size_t offsets[6];
     size_t bytes[6] = {0};
  
     for(ptype = 0; ptype < 6; ptype++) {
         offsets[ptype] = total_bytes;
         bytes[ptype] = sman->info[ptype].elsize * newMaxSlots[ptype];
         total_bytes += bytes[ptype];
     }
     /* no need to grow, already have enough */
     if (good) {
         return total_bytes;
     }
     char * newSlotsBase = (char *) myrealloc(sman->Base, total_bytes);
  
     /* If we are using VALGRIND the allocator is system malloc, and so realloc may move the base pointer.
      * Thus we need to also move the slots pointers before doing the memmove. If we are using our own
      * memory allocator the base address never moves, so this is unnecessary (but we do it anyway).*/
     for(ptype = 0; ptype < 6; ptype++) {
         sman->info[ptype].ptr = sman->info[ptype].ptr - sman->Base + newSlotsBase;
     }
  
     message(where, "SLOTS: Reserved %g MB for %ld sph, %ld stars and %ld BHs (disabled: %ld %ld %ld)\n", total_bytes / (1024.0 * 1024.0),
             newMaxSlots[0], newMaxSlots[4], newMaxSlots[5], newMaxSlots[1], newMaxSlots[2], newMaxSlots[3]);
  
     /* move the last block first since we are only increasing sizes, moving items forward.
      * No need to move the 0 block, since it is already moved to newSlotsBase in realloc.*/
     for(ptype = 5; ptype > 0; ptype--) {
         if(!SLOTS_ENABLED(ptype, sman)) continue;
         memmove(newSlotsBase + offsets[ptype],
             sman->info[ptype].ptr,
             sman->info[ptype].elsize * sman->info[ptype].size);
     }
  
     sman->Base = newSlotsBase;
  
     for(ptype = 0; ptype < 6; ptype++) {
         sman->info[ptype].ptr = newSlotsBase + offsets[ptype];
         sman->info[ptype].maxsize = newMaxSlots[ptype];
     }
     GDB_SphP = (struct sph_particle_data *) sman->info[0].ptr;
     GDB_StarP = (struct star_particle_data *) sman->info[4].ptr;
     GDB_BhP = (struct bh_particle_data *) sman->info[5].ptr;
     return total_bytes;
 }

References add, slots_manager_type::Base, slot_info::elsize, GDB_BhP, GDB_SphP, GDB_StarP, slots_manager_type::increase, slots_manager_type::info, slot_info::maxsize, message(), mymalloc, myrealloc, slot_info::ptr, ptype, slot_info::size, and SLOTS_ENABLED.

Referenced by domain_exchange_once(), fof_distribute_particles(), fof_seed(), init_alloc_particle_slot_memory(), setup_density(), setup_particles(), sfr_reserve_slots(), and test_slots_reserve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_set_enabled()

void slots_set_enabled	(	int	ptype,
		size_t	elsize,
		struct slots_manager_type *	sman
	)

Definition at line 560 of file slotsmanager.c.

 {
     sman->info[ptype].enabled = 1;
     sman->info[ptype].elsize = elsize;
     MPI_Type_contiguous(sman->info[ptype].elsize, MPI_BYTE, &MPI_TYPE_SLOT[ptype]);
     MPI_Type_commit(&MPI_TYPE_SLOT[ptype]);
 }

References slot_info::elsize, slot_info::enabled, slots_manager_type::info, MPI_TYPE_SLOT, and ptype.

Referenced by begrun(), setup_density(), and setup_particles().

Here is the caller graph for this function:

◆ slots_setup_id()

void slots_setup_id	(	const struct part_manager_type *	pman,
		struct slots_manager_type *	sman
	)

Definition at line 653 of file slotsmanager.c.

 {
     int64_t i;
     /* set up the cross check for child IDs */
     #pragma omp parallel for
     for(i = 0; i < pman->NumPart; i++)
     {
         struct slot_info info = sman->info[pman->Base[i].Type];
         if(!info.enabled)
             continue;
  
         int sind = pman->Base[i].PI;
         if(sind >= info.size || sind < 0)
             endrun(1, "Particle %d, type %d has PI index %d beyond max slot size %d.\n", i, pman->Base[i].Type, sind, info.size);
         struct particle_data_ext * sdata = (struct particle_data_ext * )(info.ptr + info.elsize * (size_t) sind);
         sdata->ReverseLink = i;
         sdata->ID = pman->Base[i].ID;
     }
 }

References part_manager_type::Base, slot_info::elsize, slot_info::enabled, endrun(), particle_data::ID, particle_data_ext::ID, slots_manager_type::info, part_manager_type::NumPart, particle_data::PI, slot_info::ptr, particle_data_ext::ReverseLink, slot_info::size, and particle_data::Type.

Referenced by petaio_read_snapshot(), and setup_particles().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slots_setup_topology()

void slots_setup_topology	(	struct part_manager_type *	pman,
		int64_t *	NLocal,
		struct slots_manager_type *	sman
	)

Definition at line 624 of file slotsmanager.c.

 {
     /* initialize particle types */
     int ptype;
     int64_t offset = 0;
     for(ptype = 0; ptype < 6; ptype ++) {
         int64_t i;
         struct slot_info info = sman->info[ptype];
         #pragma omp parallel for
         for(i = 0; i < NLocal[ptype]; i++)
         {
             size_t j = offset + i;
             pman->Base[j].Type = ptype;
             pman->Base[j].IsGarbage = 0;
             if(info.enabled)
                 pman->Base[j].PI = i;
         }
         offset += NLocal[ptype];
     }
  
     for(ptype = 0; ptype < 6; ptype ++) {
         struct slot_info info = sman->info[ptype];
         if(!info.enabled)
             continue;
         sman->info[ptype].size = NLocal[ptype];
     }
 }

References part_manager_type::Base, slot_info::enabled, slots_manager_type::info, particle_data::IsGarbage, particle_data::PI, ptype, slot_info::size, and particle_data::Type.

Referenced by init_alloc_particle_slot_memory(), and setup_particles().

Here is the caller graph for this function:

◆ slots_split_particle()

int slots_split_particle	(	int	parent,
		double	childmass,
		struct part_manager_type *	pman
	)

When a new additional star particle is created, we can put it into the tree at the position of the spawning gas particle. Multipole moments of tree nodes need not be changed.

Definition at line 103 of file slotsmanager.c.

 {
     int64_t child = atomic_fetch_and_add_64(&pman->NumPart, 1);
  
     if(child >= pman->MaxPart)
         endrun(8888, "Tried to spawn: NumPart=%ld MaxPart = %ld. Sorry, no space left.\n", child, pman->MaxPart);
  
     pman->Base[parent].Generation ++;
     uint64_t g = pman->Base[parent].Generation;
     pman->Base[child] = pman->Base[parent];
  
     /* change the child ID according to the generation. */
     pman->Base[child].ID = (pman->Base[parent].ID & 0x00ffffffffffffffL) + (g << 56L);
     if(g >= (1 << (64-56L)))
         endrun(1, "Particle %d (ID: %ld) generated too many particles: generation %ld wrapped.\n", parent, pman->Base[parent].ID, g);
  
     pman->Base[child].Mass = childmass;
     pman->Base[parent].Mass -= childmass;
  
     /*Invalidate the slot of the child. Call slots_convert soon afterwards!*/
     pman->Base[child].PI = -1;
  
     /* emit event for forcetree to deal with the new particle */
     EISlotsFork event = {
         .parent = parent,
         .child = child,
     };
  
     event_emit(&EventSlotsFork, (EIBase *) &event);
  
     return child;
 }

References atomic_fetch_and_add_64(), part_manager_type::Base, endrun(), event_emit(), EventSlotsFork, particle_data::Generation, particle_data::ID, particle_data::Mass, part_manager_type::MaxPart, part_manager_type::NumPart, EISlotsFork::parent, and particle_data::PI.

Referenced by get_sfr_eeqos(), and test_slots_fork().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ GDB_BhP

struct bh_particle_data* GDB_BhP

static

Definition at line 17 of file slotsmanager.c.

Referenced by slots_reserve().

◆ GDB_SphP

struct sph_particle_data* GDB_SphP

static

Definition at line 15 of file slotsmanager.c.

Referenced by slots_reserve().

◆ GDB_StarP

struct star_particle_data* GDB_StarP

static

Definition at line 16 of file slotsmanager.c.

Referenced by slots_reserve().

◆ MPI_TYPE_PARTICLE

MPI_Datatype MPI_TYPE_PARTICLE = 0

Definition at line 11 of file slotsmanager.c.

Referenced by domain_exchange_once(), and slots_init().

◆ MPI_TYPE_PLAN_ENTRY

MPI_Datatype MPI_TYPE_PLAN_ENTRY = 0

Definition at line 12 of file slotsmanager.c.

◆ MPI_TYPE_SLOT

MPI_Datatype MPI_TYPE_SLOT[6] = {0}

Definition at line 13 of file slotsmanager.c.

Referenced by domain_exchange_once(), and slots_set_enabled().

◆ SlotsManager

struct slots_manager_type SlotsManager[1]

Definition at line 1 of file slotsmanager.c.

Referenced by begrun(), blackhole(), blackhole_feedback_ngbiter(), blackhole_make_one(), check_density_entropy(), cooling_and_starformation(), density(), do_density_test(), domain_decompose_full(), domain_maintain(), drift_all_particles(), fof_distribute_particles(), fof_seed(), force_tree_create_nodes(), gas_ionization_fraction(), hydro_force(), init(), init_alloc_particle_slot_memory(), make_particle_star(), metal_return(), metal_return_init(), petaio_build_buffer(), petaio_read_snapshot(), petaio_readout_buffer(), petaio_save_snapshot(), run(), runfof(), setup_density(), setup_density_indep_entropy(), setup_particles(), setup_smoothinglengths(), sfr_reserve_slots(), slots_gc_sorted(), stellar_density(), teardown_particles(), test_exchange(), test_exchange_uneven(), test_exchange_with_garbage(), test_exchange_zero_slots(), test_slots_convert(), test_slots_fork(), test_slots_gc(), test_slots_gc_sorted(), test_slots_reserve(), test_slots_zero(), turn_on_quasars(), and winds_find_weights().

Macros

Functions

Variables

Macro Definition Documentation

◆ GARBAGE

◆ PART

◆ SLOTS_ENABLED

Function Documentation

◆ order_by_type_and_key()

◆ slot_cmp_reverse_link()

◆ slots_check_id_consistency()

◆ slots_connect_new_slot()

◆ slots_convert()

◆ slots_find_next_garbage()

◆ slots_find_next_nongarbage()

◆ slots_free()

◆ slots_gc()

◆ slots_gc_base()

◆ slots_gc_collect()

◆ slots_gc_compact()

◆ slots_gc_mark()

◆ slots_gc_slots()

◆ slots_gc_sorted()

◆ slots_gc_sweep()

◆ slots_get_last_garbage()

◆ slots_init()

◆ slots_mark_garbage()

◆ slots_reserve()

◆ slots_set_enabled()

◆ slots_setup_id()

◆ slots_setup_topology()

◆ slots_split_particle()

Variable Documentation

◆ GDB_BhP

◆ GDB_SphP

◆ GDB_StarP

◆ MPI_TYPE_PARTICLE

◆ MPI_TYPE_PLAN_ENTRY

◆ MPI_TYPE_SLOT

◆ SlotsManager