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; }