static int zend_shared_alloc_try(const zend_shared_memory_handler_entry *he, size_t requested_size, zend_shared_segment ***shared_segments_p, int *shared_segments_count, char **error_in)
{
int res;
g_shared_alloc_handler = he->handler;
g_shared_model = he->name;
ZSMMG(shared_segments) = NULL;
ZSMMG(shared_segments_count) = 0;
res = S_H(create_segments)(requested_size, shared_segments_p, shared_segments_count, error_in);
if (res) {
/* this model works! */
return res;
}
if (*shared_segments_p) {
int i;
/* cleanup */
for (i = 0; i < *shared_segments_count; i++) {
if ((*shared_segments_p)[i]->p && (*shared_segments_p)[i]->p != (void *)-1) {
S_H(detach_segment)((*shared_segments_p)[i]);
}
}
free(*shared_segments_p);
*shared_segments_p = NULL;
}
g_shared_alloc_handler = NULL;
return ALLOC_FAILURE;
}
//Main-Function
int main () {
double xiMax = 10;
double xiMin = -10;
double deltaXi = 0.1;
double deltaT = 0.05;
double mittelWert = 0, mittelWert2 = 0;
double impuls = 0, impuls2 = 0;
int cn = floor(10./deltaT+0.5);
int iN = 0;
std::complex<double> c_i = (0,1);
Eigen::MatrixXcd Sh = S_H(deltaT, &H, deltaXi, xiMax, xiMin);
Eigen::VectorXcd xi = init(xiMax, xiMin, deltaXi);
Eigen::VectorXcd xi_n = xi;
Eigen::VectorXcd xi_temp;
//Dateistreams für geforderte Ausgabe-Plots
std::ofstream datei("A1d_Normierung.dat");
std::ofstream datei2("A1f.dat");
//Anwenden des Zeitentwicklungsoperators bis t=10
for (int i = 0; i < cn; i++) {
xi_n = Sh*xi_n;
datei << i*deltaT << " " << Norm(xi_n) << std::endl;
//Animationssequenz
//if (i%2 == 0) {
// SchreibeZustand(xi_n, "A1d_Animation_"+convertInt(i/2));
//}
//Mittelwert des Ortes und des Impulses
for (int j = 0; j < xi.size(); j++) {
iN = j - floor(xi.size()/2);
mittelWert += iN*deltaXi*abs(xi_n(j))*abs(xi_n(j));
mittelWert2 += (iN*deltaXi)*(iN*deltaXi)*abs(xi_n(j))*abs(xi_n(j));
impuls += abs(xi_n(j)*(-c_i)*Ableitung(xi_n, j, deltaXi));
impuls2 += abs(xi_n(j)*(-1.)*Ableitung2(xi_n, j, deltaXi));
}
datei2 << i*deltaT << " " << mittelWert << " " << (mittelWert2 - mittelWert*mittelWert) << " " << impuls << " " << impuls2 << std::endl;
mittelWert = 0;
mittelWert2 = 0;
impuls = 0;
impuls2 = 0;
}
datei.close();
datei2.close();
SchreibeZustand(xi_n, "A1d_Zustand");
return 0;
}
void zend_shared_alloc_shutdown(void)
{
zend_shared_segment **tmp_shared_segments;
size_t shared_segments_array_size;
zend_smm_shared_globals tmp_shared_globals;
int i;
tmp_shared_globals = *smm_shared_globals;
smm_shared_globals = &tmp_shared_globals;
shared_segments_array_size = ZSMMG(shared_segments_count) * (S_H(segment_type_size)() + sizeof(void *));
tmp_shared_segments = emalloc(shared_segments_array_size);
copy_shared_segments(tmp_shared_segments, ZSMMG(shared_segments)[0], ZSMMG(shared_segments_count), S_H(segment_type_size)());
ZSMMG(shared_segments) = tmp_shared_segments;
for (i = 0; i < ZSMMG(shared_segments_count); i++) {
S_H(detach_segment)(ZSMMG(shared_segments)[i]);
}
efree(ZSMMG(shared_segments));
ZSMMG(shared_segments) = NULL;
g_shared_alloc_handler = NULL;
#ifndef ZEND_WIN32
close(lock_file);
#endif
}
int zend_shared_alloc_startup(size_t requested_size)
{
zend_shared_segment **tmp_shared_segments;
size_t shared_segments_array_size;
zend_smm_shared_globals tmp_shared_globals, *p_tmp_shared_globals;
char *error_in = NULL;
const zend_shared_memory_handler_entry *he;
int res = ALLOC_FAILURE;
/* shared_free must be valid before we call zend_shared_alloc()
* - make it temporarily point to a local variable
*/
smm_shared_globals = &tmp_shared_globals;
ZSMMG(shared_free) = requested_size; /* goes to tmp_shared_globals.shared_free */
zend_shared_alloc_create_lock();
if (ZCG(accel_directives).memory_model && ZCG(accel_directives).memory_model[0]) {
char *model = ZCG(accel_directives).memory_model;
/* "cgi" is really "shm"... */
if (strncmp(ZCG(accel_directives).memory_model, "cgi", sizeof("cgi")) == 0) {
model = "shm";
}
for (he = handler_table; he->name; he++) {
if (strcmp(model, he->name) == 0) {
res = zend_shared_alloc_try(he, requested_size, &ZSMMG(shared_segments), &ZSMMG(shared_segments_count), &error_in);
if (res) {
/* this model works! */
}
break;
}
}
}
if (res == FAILED_REATTACHED) {
smm_shared_globals = NULL;
return res;
}
#if ENABLE_FILE_CACHE_FALLBACK
if (ALLOC_FALLBACK == res) {
return ALLOC_FALLBACK;
}
#endif
if (!g_shared_alloc_handler) {
/* try memory handlers in order */
for (he = handler_table; he->name; he++) {
res = zend_shared_alloc_try(he, requested_size, &ZSMMG(shared_segments), &ZSMMG(shared_segments_count), &error_in);
if (res) {
/* this model works! */
break;
}
}
}
if (!g_shared_alloc_handler) {
no_memory_bailout(requested_size, error_in);
return ALLOC_FAILURE;
}
if (res == SUCCESSFULLY_REATTACHED) {
return res;
}
#if ENABLE_FILE_CACHE_FALLBACK
if (ALLOC_FALLBACK == res) {
return ALLOC_FALLBACK;
}
#endif
shared_segments_array_size = ZSMMG(shared_segments_count) * S_H(segment_type_size)();
/* move shared_segments and shared_free to shared memory */
ZCG(locked) = 1; /* no need to perform a real lock at this point */
p_tmp_shared_globals = (zend_smm_shared_globals *) zend_shared_alloc(sizeof(zend_smm_shared_globals));
if (!p_tmp_shared_globals) {
zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
return ALLOC_FAILURE;;
}
tmp_shared_segments = zend_shared_alloc(shared_segments_array_size + ZSMMG(shared_segments_count) * sizeof(void *));
if (!tmp_shared_segments) {
zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
return ALLOC_FAILURE;;
}
copy_shared_segments(tmp_shared_segments, ZSMMG(shared_segments)[0], ZSMMG(shared_segments_count), S_H(segment_type_size)());
*p_tmp_shared_globals = tmp_shared_globals;
smm_shared_globals = p_tmp_shared_globals;
free(ZSMMG(shared_segments));
ZSMMG(shared_segments) = tmp_shared_segments;
ZSMMG(shared_memory_state).positions = (int *)zend_shared_alloc(sizeof(int) * ZSMMG(shared_segments_count));
if (!ZSMMG(shared_memory_state).positions) {
zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
return ALLOC_FAILURE;;
}
ZCG(locked) = 0;
return res;
}
