slotsmanager.h File Reference

#include <mpi.h>
#include "utils.h"
#include "types.h"
#include "partmanager.h"

Include dependency graph for slotsmanager.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	slot_info
struct	particle_data_ext
struct	bh_particle_data
struct	star_particle_data
struct	sph_particle_data
struct	slots_manager_type
struct	EISlotsFork

Macros
#define	NMETALS   9
#define	SphP   ((struct sph_particle_data*) SlotsManager->info[0].ptr)
#define	StarP   ((struct star_particle_data*) SlotsManager->info[4].ptr)
#define	BhP   ((struct bh_particle_data*) SlotsManager->info[5].ptr)
#define	SPHP(i)   SphP[P[i].PI]
#define	BHP(i)   BhP[P[i].PI]
#define	STARP(i)   StarP[P[i].PI]
#define	BASESLOT_PI(PI, ptype, sman)   ((struct particle_data_ext *)(sman->info[ptype].ptr + sman->info[ptype].elsize * (PI)))

Functions
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_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)
int	slots_split_particle (int parent, double childmass, struct part_manager_type *pman)
int	slots_convert (int parent, int ptype, int placement, struct part_manager_type *pman, struct slots_manager_type *sman)
int	slots_gc (int *compact_slots, struct part_manager_type *pman, 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_check_id_consistency (struct part_manager_type *pman, struct slots_manager_type *sman)

Variables
struct slots_manager_type	SlotsManager [1]
MPI_Datatype	MPI_TYPE_PARTICLE
MPI_Datatype	MPI_TYPE_SLOT [6]

Macro Definition Documentation

BASESLOT_PI

#define BASESLOT_PI	(		PI,
			ptype,
			sman
	)		((struct particle_data_ext *)(sman->info[ptype].ptr + sman->info[ptype].elsize * (PI)))

Definition at line 132 of file slotsmanager.h.

BhP

#define BhP   ((struct bh_particle_data*) SlotsManager->info[5].ptr)

Definition at line 121 of file slotsmanager.h.

BHP

#define BHP

(

i

)

BhP[P[i].PI]

Definition at line 125 of file slotsmanager.h.

NMETALS

#define NMETALS   9

Definition at line 60 of file slotsmanager.h.

SphP

#define SphP   ((struct sph_particle_data*) SlotsManager->info[0].ptr)

Definition at line 119 of file slotsmanager.h.

SPHP

#define SPHP

(

i

)

SphP[P[i].PI]

Definition at line 124 of file slotsmanager.h.

StarP

#define StarP   ((struct star_particle_data*) SlotsManager->info[4].ptr)

Definition at line 120 of file slotsmanager.h.

STARP

#define STARP

(

i

)

StarP[P[i].PI]

Definition at line 126 of file slotsmanager.h.

Function Documentation

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_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_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_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_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

MPI_TYPE_PARTICLE

MPI_Datatype MPI_TYPE_PARTICLE

extern

Definition at line 11 of file slotsmanager.c.

Referenced by domain_exchange_once(), and slots_init().

MPI_TYPE_SLOT

MPI_Datatype MPI_TYPE_SLOT[6]

extern

Definition at line 13 of file slotsmanager.c.

Referenced by domain_exchange_once(), and slots_set_enabled().

SlotsManager

struct slots_manager_type SlotsManager[1]