Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F79505534
allocate.c
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Mon, Aug 26, 19:30
Size
7 KB
Mime Type
text/x-c
Expires
Wed, Aug 28, 19:30 (2 d)
Engine
blob
Format
Raw Data
Handle
20197716
Attached To
rPNBODY pNbody
allocate.c
View Options
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "allvars.h"
#include "proto.h"
/*! \file allocate.c
* \brief routines for allocating particle and tree storage
*/
/*! Allocates a number of small buffers and arrays, the largest one being
* the communication buffer. The communication buffer itself is mapped
* onto various tables used in the different parts of the force
* algorithms. We further allocate space for the top-level tree nodes, and
* auxiliary arrays for the domain decomposition algorithm.
*/
void
allocate_commbuffers
(
void
)
{
size_t
bytes
;
Exportflag
=
malloc
(
NTask
*
sizeof
(
char
));
DomainStartList
=
malloc
(
NTask
*
sizeof
(
int
));
DomainEndList
=
malloc
(
NTask
*
sizeof
(
int
));
TopNodes
=
malloc
(
MAXTOPNODES
*
sizeof
(
struct
topnode_data
));
DomainWork
=
malloc
(
MAXTOPNODES
*
sizeof
(
double
));
DomainCount
=
malloc
(
MAXTOPNODES
*
sizeof
(
int
));
DomainCountSph
=
malloc
(
MAXTOPNODES
*
sizeof
(
int
));
DomainTask
=
malloc
(
MAXTOPNODES
*
sizeof
(
int
));
DomainNodeIndex
=
malloc
(
MAXTOPNODES
*
sizeof
(
int
));
DomainTreeNodeLen
=
malloc
(
MAXTOPNODES
*
sizeof
(
FLOAT
));
DomainHmax
=
malloc
(
MAXTOPNODES
*
sizeof
(
FLOAT
));
DomainMoment
=
malloc
(
MAXTOPNODES
*
sizeof
(
struct
DomainNODE
));
if
(
!
(
CommBuffer
=
malloc
(
bytes
=
All
.
BufferSize
*
1024
*
1024
)))
{
printf
(
"failed to allocate memory for `CommBuffer' (%g MB).
\n
"
,
bytes
/
(
1024.0
*
1024.0
));
endrun
(
2
);
}
All
.
BunchSizeForce
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
sizeof
(
struct
gravdata_index
)
+
2
*
sizeof
(
struct
gravdata_in
));
if
(
All
.
BunchSizeForce
&
1
)
All
.
BunchSizeForce
-=
1
;
/* make sure that All.BunchSizeForce is an even number
--> 8-byte alignment for 64bit processors */
GravDataIndexTable
=
(
struct
gravdata_index
*
)
CommBuffer
;
GravDataIn
=
(
struct
gravdata_in
*
)
(
GravDataIndexTable
+
All
.
BunchSizeForce
);
GravDataGet
=
GravDataIn
+
All
.
BunchSizeForce
;
GravDataOut
=
GravDataIn
;
/* this will overwrite the GravDataIn-Table */
GravDataResult
=
GravDataGet
;
/* this will overwrite the GravDataGet-Table */
All
.
BunchSizeDensity
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
2
*
sizeof
(
struct
densdata_in
)
+
2
*
sizeof
(
struct
densdata_out
));
DensDataIn
=
(
struct
densdata_in
*
)
CommBuffer
;
DensDataGet
=
DensDataIn
+
All
.
BunchSizeDensity
;
DensDataResult
=
(
struct
densdata_out
*
)
(
DensDataGet
+
All
.
BunchSizeDensity
);
DensDataPartialResult
=
DensDataResult
+
All
.
BunchSizeDensity
;
All
.
BunchSizeHydro
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
2
*
sizeof
(
struct
hydrodata_in
)
+
2
*
sizeof
(
struct
hydrodata_out
));
HydroDataIn
=
(
struct
hydrodata_in
*
)
CommBuffer
;
HydroDataGet
=
HydroDataIn
+
All
.
BunchSizeHydro
;
HydroDataResult
=
(
struct
hydrodata_out
*
)
(
HydroDataGet
+
All
.
BunchSizeHydro
);
HydroDataPartialResult
=
HydroDataResult
+
All
.
BunchSizeHydro
;
#ifdef MULTIPHASE
All
.
BunchSizeSticky
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
2
*
sizeof
(
struct
stickydata_in
)
+
2
*
sizeof
(
struct
stickydata_out
));
StickyDataIn
=
(
struct
stickydata_in
*
)
CommBuffer
;
StickyDataGet
=
StickyDataIn
+
All
.
BunchSizeSticky
;
StickyDataResult
=
(
struct
stickydata_out
*
)
(
StickyDataGet
+
All
.
BunchSizeSticky
);
StickyDataPartialResult
=
StickyDataResult
+
All
.
BunchSizeSticky
;
#endif
#ifdef CHIMIE
All
.
BunchSizeChimie
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
2
*
sizeof
(
struct
chimiedata_in
)
+
2
*
sizeof
(
struct
chimiedata_out
));
ChimieDataIn
=
(
struct
chimiedata_in
*
)
CommBuffer
;
ChimieDataGet
=
ChimieDataIn
+
All
.
BunchSizeChimie
;
ChimieDataResult
=
(
struct
chimiedata_out
*
)
(
ChimieDataGet
+
All
.
BunchSizeChimie
);
ChimieDataPartialResult
=
ChimieDataResult
+
All
.
BunchSizeChimie
;
All
.
BunchSizeStarsDensity
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
2
*
sizeof
(
struct
starsdensdata_in
)
+
2
*
sizeof
(
struct
starsdensdata_out
));
StarsDensDataIn
=
(
struct
starsdensdata_in
*
)
CommBuffer
;
StarsDensDataGet
=
StarsDensDataIn
+
All
.
BunchSizeStarsDensity
;
StarsDensDataResult
=
(
struct
starsdensdata_out
*
)
(
StarsDensDataGet
+
All
.
BunchSizeStarsDensity
);
StarsDensDataPartialResult
=
StarsDensDataResult
+
All
.
BunchSizeStarsDensity
;
#endif
#ifdef STELLAR_PROP
All
.
BunchSizeDomain
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
sizeof
(
struct
particle_data
)
+
sizeof
(
struct
sph_particle_data
)
+
sizeof
(
struct
st_particle_data
)
+
sizeof
(
peanokey
));
#else
All
.
BunchSizeDomain
=
(
All
.
BufferSize
*
1024
*
1024
)
/
(
sizeof
(
struct
particle_data
)
+
sizeof
(
struct
sph_particle_data
)
+
sizeof
(
peanokey
));
#endif
if
(
All
.
BunchSizeDomain
&
1
)
All
.
BunchSizeDomain
-=
1
;
/* make sure that All.BunchSizeDomain is even
--> 8-byte alignment of DomainKeyBuf for 64bit processors */
DomainPartBuf
=
(
struct
particle_data
*
)
CommBuffer
;
DomainSphBuf
=
(
struct
sph_particle_data
*
)
(
DomainPartBuf
+
All
.
BunchSizeDomain
);
DomainKeyBuf
=
(
peanokey
*
)
(
DomainSphBuf
+
All
.
BunchSizeDomain
);
#ifdef STELLAR_PROP
DomainStBuf
=
(
struct
st_particle_data
*
)
(
DomainKeyBuf
+
All
.
BunchSizeDomain
);
#endif
if
(
ThisTask
==
0
)
{
printf
(
"
\n
Allocated %d MByte communication buffer per processor.
\n\n
"
,
All
.
BufferSize
);
printf
(
"Communication buffer has room for %d particles in gravity computation
\n
"
,
All
.
BunchSizeForce
);
printf
(
"Communication buffer has room for %d particles in density computation
\n
"
,
All
.
BunchSizeDensity
);
printf
(
"Communication buffer has room for %d particles in hydro computation
\n
"
,
All
.
BunchSizeHydro
);
printf
(
"Communication buffer has room for %d particles in domain decomposition
\n
"
,
All
.
BunchSizeDomain
);
printf
(
"
\n
"
);
}
}
/*! This routine allocates memory for particle storage, both the
* collisionless and the SPH particles.
*/
void
allocate_memory
(
void
)
{
size_t
bytes
;
double
bytes_tot
=
0
;
if
(
All
.
MaxPart
>
0
)
{
if
(
!
(
P
=
malloc
(
bytes
=
All
.
MaxPart
*
sizeof
(
struct
particle_data
))))
{
printf
(
"failed to allocate memory for `P' (%g MB).
\n
"
,
bytes
/
(
1024.0
*
1024.0
));
endrun
(
1
);
}
bytes_tot
+=
bytes
;
if
(
ThisTask
==
0
)
printf
(
"
\n
Allocated %g MByte for particle storage. %d
\n\n
"
,
bytes_tot
/
(
1024.0
*
1024.0
),
sizeof
(
struct
particle_data
));
}
if
(
All
.
MaxPartSph
>
0
)
{
bytes_tot
=
0
;
if
(
!
(
SphP
=
malloc
(
bytes
=
All
.
MaxPartSph
*
sizeof
(
struct
sph_particle_data
))))
{
printf
(
"failed to allocate memory for `SphP' (%g MB) %d.
\n
"
,
bytes
/
(
1024.0
*
1024.0
),
sizeof
(
struct
sph_particle_data
));
endrun
(
1
);
}
bytes_tot
+=
bytes
;
if
(
ThisTask
==
0
)
printf
(
"Allocated %g MByte for storage of SPH data. %d
\n\n
"
,
bytes_tot
/
(
1024.0
*
1024.0
),
sizeof
(
struct
sph_particle_data
));
}
#ifdef STELLAR_PROP
if
(
All
.
MaxPartStars
>
0
)
{
bytes_tot
=
0
;
if
(
!
(
StP
=
malloc
(
bytes
=
All
.
MaxPartStars
*
sizeof
(
struct
st_particle_data
))))
{
printf
(
"failed to allocate memory for `StP' (%g MB).
\n
"
,
bytes
/
(
1024.0
*
1024.0
));
endrun
(
1
);
}
bytes_tot
+=
bytes
;
if
(
ThisTask
==
0
)
printf
(
"
\n
Allocated %g MByte for star properties storage. %d
\n\n
"
,
bytes_tot
/
(
1024.0
*
1024.0
),
sizeof
(
struct
st_particle_data
));
}
#endif
}
/*! This routine frees the memory for the particle storage. Note: We don't
* actually bother to call it in the code... When the program terminats,
* the memory will be automatically freed by the operating system.
*/
void
free_memory
(
void
)
{
#ifdef STELLAR_PROP
if
(
All
.
MaxPartStars
>
0
)
free
(
StP
);
#endif
if
(
All
.
MaxPartSph
>
0
)
free
(
SphP
);
if
(
All
.
MaxPart
>
0
)
free
(
P
);
}
Event Timeline
Log In to Comment