Changeset 254

eaccelerator/trunk/ChangeLog

r253	r254
4	4	faster and provides a much better distribution.
5	5	* Don't compile the user cache code one no feature is being compiled.
	6	* A big cleanup in struct naming
6	7
7	8	2006-07-29 Bart Vanbrabant <bart.vanbrabant at zoeloelip.be>

eaccelerator/trunk/cache.c

r253	r254
29	29	#include "eaccelerator_version.h"
30	30
31		#if ~~defined(HAVE_EACCELERATOR) && (defined(WITH_EACCELERATOR_CONTENT_CACHING) \|\| defined(WITH_EACCELERATOR_SESSIONS) \|\| defined(WITH_EACCELERATOR_SHM))~~
	31	#ifdef HAVE_EACCELERATOR
32	32
33	33	#include "zend.h"
…	…
44	44
45	45	/* variables needed from eaccelerator.c */
46		extern long ea~~ccelerator~~_shm_max;
	46	extern long ea_shm_max;
47	47	extern eaccelerator_mm *eaccelerator_mm_instance;
48	48	extern int binary_eaccelerator_version;
49	49	extern int binary_php_version;
50	50	extern int binary_zend_version;
	51
	52	#if defined(WITH_EACCELERATOR_CONTENT_CACHING) \|\| defined(WITH_EACCELERATOR_SESSIONS) \|\| defined(WITH_EACCELERATOR_SHM)
51	53
52	54	static char build_key(const char key, int key_len, int *xlen TSRMLS_DC)
…	…
91	93	int xlen;
92	94	char *xkey;
93		mm_lock_entry *x;
94		mm_lock_entry **p;
	95	ea_lock_entry *x;
	96	ea_lock_entry **p;
95	97	int ok = 0;
96	98
…	…
100	102	xkey = build_key(key, key_len, &xlen TSRMLS_CC);
101	103	EACCELERATOR_UNPROTECT();
102		x = eaccelerator_malloc(offsetof(mm_lock_entry, key) + xlen + 1);
	104	x = eaccelerator_malloc(offsetof(ea_lock_entry, key) + xlen + 1);
103	105	if (x == NULL) {
104	106	EACCELERATOR_PROTECT();
…	…
161	163	int xlen;
162	164	char *xkey;
163		mm_lock_entry **p;
	165	ea_lock_entry **p;
164	166
165	167	if (eaccelerator_mm_instance == NULL)
…	…
177	179	if ((*p)->pid == getpid()) {
178	180	#endif
179		mm_lock_entry x = (p);
	181	ea_lock_entry x = (p);
180	182	p = (p)->next;
181	183	eaccelerator_free_nolock(x);
…	…
201	203
202	204	/* put a key in the cache (shm or disk) */
203		int eaccelerator_put(const char key, int key_len, zval val, time_t ttl,
204		eaccelerator_cache_place where TSRMLS_DC)
205		{
206		mm_user_cache_entry p, q;
	205	int eaccelerator_put(const char key, int key_len, zval val, time_t ttl, ea_cache_place where TSRMLS_DC)
	206	{
	207	ea_user_cache_entry p, q;
207	208	unsigned int slot, hv;
208	209	long size;
…	…
218	219	zend_hash_init(&EAG(strings), 0, NULL, NULL, 0);
219	220	EACCELERATOR_ALIGN(EAG(mem));
220		EAG(mem) += offsetof(mm_user_cache_entry, key) + xlen + 1;
	221	EAG(mem) += offsetof(ea_user_cache_entry, key) + xlen + 1;
221	222	calc_zval(val TSRMLS_CC);
222	223	zend_hash_destroy(&EAG(strings));
…	…
225	226
226	227	EAG(mem) = NULL;
227		if (eaccelerator_mm_instance != NULL && (where == eaccelerator_shm_and_disk \|\|
228		where == eaccelerator_shm \|\| where == eaccelerator_shm_only)) {
	228	if (eaccelerator_mm_instance != NULL && (where == ea_shm_and_disk \|\| where == ea_shm \|\| where == ea_shm_only)) {
229	229	EACCELERATOR_UNPROTECT();
230		if (ea~~ccelerator_shm_max == 0 \|\| size <= eaccelerator~~_shm_max) {
	230	if (ea_shm_max == 0 \|\| size <= ea_shm_max) {
231	231	EAG(mem) = eaccelerator_malloc(size);
232	232	if (EAG(mem) == NULL) {
…	…
238	238	}
239	239	}
240		if (EAG(mem) == NULL && (where == eaccelerator_shm_and_disk \|\|
241		where == eaccelerator_shm \|\| where == eaccelerator_disk_only)) {
	240	if (EAG(mem) == NULL && (where == ea_shm_and_disk \|\| where == ea_shm \|\| where == ea_disk_only)) {
242	241	use_shm = 0;
243	242	EAG(mem) = emalloc(size);
…	…
246	245	zend_hash_init(&EAG(strings), 0, NULL, NULL, 0);
247	246	EACCELERATOR_ALIGN(EAG(mem));
248		q = (mm_user_cache_entry *) EAG(mem);
	247	q = (ea_user_cache_entry *) EAG(mem);
249	248	q->size = size;
250		EAG(mem) += offsetof(mm_user_cache_entry, key) + xlen + 1;
	249	EAG(mem) += offsetof(ea_user_cache_entry, key) + xlen + 1;
251	250	q->hv = zend_get_hash_value(xkey, xlen);
252	251	memcpy(q->key, xkey, xlen + 1);
…	…
262	261	* storing to file
263	262	*/
264		if ((where == ea~~ccelerator_shm_and_disk \|\| ((where == eaccelerator_shm) && !use_shm) \|\|~~
265		~~where == eaccelerator_disk_only) &&~~ eaccelerator_md5(s, "/eaccelerator-user-", q->key TSRMLS_CC)) {
	263	if ((where == ea_shm_and_disk \|\| ((where == ea_shm) && !use_shm) \|\| where == ea_disk_only) &&
	264	eaccelerator_md5(s, "/eaccelerator-user-", q->key TSRMLS_CC)) {
266	265	int f;
267	266	unlink(s);
268	267	f = open(s, O_CREAT \| O_WRONLY \| O_EXCL \| O_BINARY, S_IRUSR \| S_IWUSR);
269	268	if (f > 0) {
270		mm_file_header hdr;
	269	ea_file_header hdr;
271	270	EACCELERATOR_FLOCK(f, LOCK_EX);
272	271	strncpy(hdr.magic, EA_MAGIC, 8);
…	…
294	293	}
295	294
296		if ((where == ea~~ccelerator_shm_and_disk \|\| where == eaccelerator_shm \|\| where == eaccelerator~~_shm_only) && use_shm) {
	295	if ((where == ea_shm_and_disk \|\| where == ea_shm \|\| where == ea_shm_only) && use_shm) {
297	296	/*
298	297	* storing to shared memory
…	…
327	326
328	327	/* get a key from the cache */
329		int eaccelerator_get(const char key, int key_len, zval return_value,
330		eaccelerator_cache_place where TSRMLS_DC)
	328	int eaccelerator_get(const char key, int key_len, zval return_value, ea_cache_place where TSRMLS_DC)
331	329	{
332	330	unsigned int hv, slot;
…	…
339	337	slot = hv & EA_USER_HASH_MAX;
340	338
341		if (eaccelerator_mm_instance != NULL && (where == eaccelerator_shm_and_disk
342		\|\| where == eaccelerator_shm \|\| where == eaccelerator_shm_only)) {
343		mm_user_cache_entry p, q;
344		mm_user_cache_entry *x = NULL;
	339	if (eaccelerator_mm_instance != NULL && (where == ea_shm_and_disk \|\| where == ea_shm \|\| where == ea_shm_only)) {
	340	ea_user_cache_entry p, q;
	341	ea_user_cache_entry *x = NULL;
345	342	EACCELERATOR_UNPROTECT();
346	343	EACCELERATOR_LOCK_RW();
…	…
380	377	* key is not found in shared memory try to load it from file
381	378	*/
382		if ((where == eaccelerator_shm_and_disk \|\| where == eaccelerator_shm \|\|
383		where == eaccelerator_disk_only) &&
	379	if ((where == ea_shm_and_disk \|\| where == ea_shm \|\| where == ea_disk_only) &&
384	380	eaccelerator_md5(s, "/eaccelerator-user-", xkey TSRMLS_CC)) {
385	381	time_t t = time(0);
…	…
389	385
390	386	if ((f = open(s, O_RDONLY \| O_BINARY)) > 0) {
391		mm_file_header hdr;
	387	ea_file_header hdr;
392	388
393	389	EACCELERATOR_FLOCK(f, LOCK_SH);
…	…
406	402	* try to put it into shared memory
407	403	*/
408		mm_user_cache_entry *p = NULL;
409		if (eaccelerator_mm_instance != NULL && (where == ea~~ccelerator_shm_and_disk \|\| where == eaccelerator~~_shm)) {
410		if (ea~~ccelerator_shm_max == 0 \|\| hdr.size <= eaccelerator~~_shm_max) {
	404	ea_user_cache_entry *p = NULL;
	405	if (eaccelerator_mm_instance != NULL && (where == ea_shm_and_disk \|\| where == ea_shm)) {
	406	if (ea_shm_max == 0 \|\| hdr.size <= ea_shm_max) {
411	407	EACCELERATOR_UNPROTECT();
412	408	p = eaccelerator_malloc(hdr.size);
…	…
453	449	if (use_shm) {
454	450	/* put it into shared memory */
455		mm_user_cache_entry q, prev;
	451	ea_user_cache_entry q, prev;
456	452
457	453	p->hv = hv;
…	…
509	505
510	506	/* remove a key from the cache */
511		int eaccelerator_rm(const char *key, int key_len,
512		eaccelerator_cache_place where TSRMLS_DC)
	507	int eaccelerator_rm(const char *key, int key_len, ea_cache_place where TSRMLS_DC)
513	508	{
514	509	unsigned int hv, slot;
515		mm_user_cache_entry p, q;
	510	ea_user_cache_entry p, q;
516	511	char s[MAXPATHLEN];
517	512	int xlen;
…	…
522	517	* removing file
523	518	*/
524		if ((where == ea~~ccelerator_shm_and_disk \|\| where == eaccelerator_shm \|\|~~
525		~~where == eaccelerator_disk_only) &&~~ eaccelerator_md5(s, "/eaccelerator-user-", xkey TSRMLS_CC)) {
	519	if ((where == ea_shm_and_disk \|\| where == ea_shm \|\| where == ea_disk_only) &&
	520	eaccelerator_md5(s, "/eaccelerator-user-", xkey TSRMLS_CC)) {
526	521	unlink(s);
527	522	}
…	…
530	525	* removing from shared memory
531	526	*/
532		if (eaccelerator_mm_instance != NULL && (where == ea~~ccelerator~~_shm_and_disk \|\|
533		where == ea~~ccelerator_shm \|\| where == eaccelerator~~_shm_only)) {
	527	if (eaccelerator_mm_instance != NULL && (where == ea_shm_and_disk \|\|
	528	where == ea_shm \|\| where == ea_shm_only)) {
534	529	hv = zend_get_hash_value(xkey, xlen);
535	530	slot = hv & EA_USER_HASH_MAX;
…	…
561	556	return 1;
562	557	}
	558	#endif
563	559
564	560	/* do garbage collection on the keys */
…	…
575	571	EACCELERATOR_LOCK_RW();
576	572	for (i = 0; i < EA_USER_HASH_SIZE; i++) {
577		mm_user_cache_entry **p = &eaccelerator_mm_instance->user_hash[i];
	573	ea_user_cache_entry **p = &eaccelerator_mm_instance->user_hash[i];
578	574	while (*p != NULL) {
579	575	if ((p)->ttl != 0 && (p)->ttl < t) {
580		mm_user_cache_entry r = p;
	576	ea_user_cache_entry r = p;
581	577	p = (p)->next;
582	578	eaccelerator_mm_instance->user_hash_cnt--;
…	…
593	589	}
594	590
	591	#ifdef WITH_EACCELERATOR_INFO
595	592	/* get list of all keys stored in memory that matches hostname or namespace */
596	593	int eaccelerator_list_keys(zval *return_value TSRMLS_DC)
…	…
599	596	zval *list;
600	597	char *xkey = "";
601		mm_user_cache_entry *p;
	598	ea_user_cache_entry *p;
602	599	time_t t = time(0);
603	600
…	…
654	651	return 1;
655	652	}
	653	#endif /* WITH_EACCELERATOR_INFO */
656	654
657	655	#endif /* HAVE_EACCELERATOR */

eaccelerator/trunk/cache.h

r182	r254
35	35	#include "zend_extensions.h"
36	36
37		int eaccelerator_put (const char key, int key_len, zval val, time_t ttl,
38		eaccelerator_cache_place where TSRMLS_DC);
39		int eaccelerator_get (const char key, int key_len, zval return_value,
40		eaccelerator_cache_place where TSRMLS_DC);
41		int eaccelerator_rm (const char *key, int key_len,
42		eaccelerator_cache_place where TSRMLS_DC);
	37	#if defined(WITH_EACCELERATOR_CONTENT_CACHING) \|\| defined(WITH_EACCELERATOR_SESSIONS) \|\| defined(WITH_EACCELERATOR_SHM)
	38	int eaccelerator_put (const char key, int key_len, zval val, time_t ttl, ea_cache_place where TSRMLS_DC);
	39	int eaccelerator_get (const char key, int key_len, zval return_value, ea_cache_place where TSRMLS_DC);
	40	int eaccelerator_rm (const char *key, int key_len, ea_cache_place where TSRMLS_DC);
	41	#endif
43	42	size_t eaccelerator_gc (TSRMLS_D);
44	43
	44
	45	#ifdef WITH_EACCELERATOR_INFO
45	46	int eaccelerator_list_keys(zval *return_value TSRMLS_DC);
	47	#endif
46	48
47	49	#endif /* INCLUDED_CACHE_H */

eaccelerator/trunk/content.c

r228	r254
37	37	#define EACCELERATOR_COMPRESS_MIN 128
38	38
39		ea~~ccelerator_cache_place eaccelerator_content_cache_place = eaccelerator~~_shm_and_disk;
	39	ea_cache_place eaccelerator_content_cache_place = ea_shm_and_disk;
40	40
41	41	static int (eaccelerator_old_header_handler)(sapi_header_struct sapi_header, sapi_headers_struct *sapi_headers TSRMLS_DC);
42	42
43		PHP_INI_MH (eaccelerator_OnUpdateContentCachePlace)
	43	PHP_INI_MH(eaccelerator_OnUpdateContentCachePlace)
44	44	{
45		if (strncasecmp ("shm_and_disk", new_value,
46		sizeof ("shm_and_disk")) == 0)
47		{
48		eaccelerator_content_cache_place = eaccelerator_shm_and_disk;
49		}
50		else if (strncasecmp ("shm", new_value,
51		sizeof ("shm")) == 0)
52		{
53		eaccelerator_content_cache_place = eaccelerator_shm;
54		}
55		else if (strncasecmp ("shm_only", new_value,
56		sizeof ("shm_only")) == 0)
57		{
58		eaccelerator_content_cache_place = eaccelerator_shm_only;
59		}
60		else if (strncasecmp ("disk_only", new_value,
61		sizeof ("disk_only")) == 0)
62		{
63		eaccelerator_content_cache_place = eaccelerator_disk_only;
64		}
65		else if (strncasecmp ("none", new_value,
66		sizeof ("none")) == 0)
67		{
68		eaccelerator_content_cache_place = eaccelerator_none;
	45	if (strncasecmp("shm_and_disk", new_value, sizeof("shm_and_disk")) == 0) {
	46	eaccelerator_content_cache_place = ea_shm_and_disk;
	47	} else if (strncasecmp("shm", new_value, sizeof("shm")) == 0) {
	48	eaccelerator_content_cache_place = ea_shm;
	49	} else if (strncasecmp("shm_only", new_value, sizeof("shm_only")) == 0) {
	50	eaccelerator_content_cache_place = ea_shm_only;
	51	} else if (strncasecmp("disk_only", new_value, sizeof("disk_only")) == 0) {
	52	eaccelerator_content_cache_place = ea_disk_only;
	53	} else if (strncasecmp("none", new_value, sizeof("none")) == 0) {
	54	eaccelerator_content_cache_place = ea_none;
69	55	}
70	56	return SUCCESS;
…	…
108	94
109	95	void eaccelerator_content_cache_startup() {
110		if (eaccelerator_content_cache_place != ea~~ccelerator~~_none) {
	96	if (eaccelerator_content_cache_place != ea_none) {
111	97	eaccelerator_old_header_handler = sapi_module.header_handler;
112	98	sapi_module.header_handler = eaccelerator_header_handler;
…	…
115	101
116	102	void eaccelerator_content_cache_shutdown() {
117		if (eaccelerator_content_cache_place != ea~~ccelerator~~_none) {
	103	if (eaccelerator_content_cache_place != ea_none) {
118	104	sapi_module.header_handler = eaccelerator_old_header_handler;
119	105	}
…	…
397	383	RETURN_FALSE;
398	384	}
399		if (eaccelerator_content_cache_place == ea~~ccelerator~~_none) {
	385	if (eaccelerator_content_cache_place == ea_none) {
400	386	RETURN_FALSE;
401	387	}
…	…
512	498	return;
513	499	}
514		if (eaccelerator_content_cache_place == ea~~ccelerator~~_none) {
	500	if (eaccelerator_content_cache_place == ea_none) {
515	501	RETURN_NULL();
516	502	}
…	…
541	527	return;
542	528	}
543		if (eaccelerator_content_cache_place == ea~~ccelerator~~_none) {
	529	if (eaccelerator_content_cache_place == ea_none) {
544	530	eval_name = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
545	531	zend_eval_string(code, NULL, eval_name TSRMLS_CC);
…	…
593	579	return;
594	580	}
595		if ((eaccelerator_content_cache_place != ea~~ccelerator~~_none) &&
	581	if ((eaccelerator_content_cache_place != ea_none) &&
596	582	eaccelerator_get(key, key_len, return_value, eaccelerator_content_cache_place TSRMLS_CC)) {
597	583	/* Return value is cached. Return it. */
…	…
601	587	eval_name = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
602	588	if (zend_eval_string(code, return_value, eval_name TSRMLS_CC) == SUCCESS &&
603		eaccelerator_content_cache_place != ea~~ccelerator~~_none) {
	589	eaccelerator_content_cache_place != ea_none) {
604	590
605	591	#ifndef ZEND_ENGINE_2_1

eaccelerator/trunk/ea_dasm.c

r229	r254
197	197	* }
198	198	*/
199		static zval get_op_array(ea~~ccelerator~~_op_array op_array TSRMLS_DC)
	199	static zval get_op_array(ea_op_array op_array TSRMLS_DC)
200	200	{
201	201	zval *return_value;
…	…
505	505
506	506	/* {{{ get_cache_entry: get the cache_entry for the given file */
507		static mm_cache_entry get_cache_entry(const char file) {
	507	static ea_cache_entry get_cache_entry(const char file) {
508	508	unsigned int slot;
509		mm_cache_entry *p;
510		mm_cache_entry *result = NULL;
	509	ea_cache_entry *p;
	510	ea_cache_entry *result = NULL;
511	511
512	512	if (file != NULL) {
…	…
548	548	const char *file;
549	549	int file_len;
550		mm_cache_entry *p;
551		mm_fc_entry *fc;
	550	ea_cache_entry *p;
	551	ea_fc_entry *fc;
552	552	zval *functions;
553	553	zval *classes;
…	…
575	575	array_init(functions);
576	576	while (fc != NULL) {
577		add_assoc_zval(functions, fc->htabkey, get_op_array((ea~~ccelerator~~_op_array *)fc->fc TSRMLS_CC));
	577	add_assoc_zval(functions, fc->htabkey, get_op_array((ea_op_array *)fc->fc TSRMLS_CC));
578	578	fc = fc->next;
579	579	}
…	…
586	586	if (fc != NULL) {
587	587	while (fc != NULL) {
588		ea~~ccelerator_class_entry c = (eaccelerator~~_class_entry ) fc->fc;
	588	ea_class_entry c = (ea_class_entry ) fc->fc;
589	589	if (c->type == ZEND_USER_CLASS) { /* get methods */
590	590	zval *methods;
…	…
595	595	q = c->function_table.pListHead;
596	596	while (q) {
597		ea~~ccelerator_op_array func = (eaccelerator~~_op_array ) q->pData;
	597	ea_op_array func = (ea_op_array ) q->pData;
598	598	if (func->type == ZEND_USER_FUNCTION) {
599	599	add_assoc_zval(methods, func->function_name, get_op_array(func TSRMLS_CC));

eaccelerator/trunk/ea_info.c

r237	r254
142	142
143	143	if ((f = open(file, O_RDONLY \| O_BINARY)) > 0) {
144		mm_file_header hdr;
	144	ea_file_header hdr;
145	145	EACCELERATOR_FLOCK (f, LOCK_SH);
146	146	if (read(f, &hdr, sizeof(hdr)) != sizeof(hdr)
…	…
293	293	{
294	294	unsigned int i;
295		mm_cache_entry *p;
	295	ea_cache_entry *p;
296	296
297	297	if (!isAdminAllowed(TSRMLS_C)) {
…	…
305	305	p = eaccelerator_mm_instance->hash[i];
306	306	while (p != NULL) {
307		mm_cache_entry *r = p;
	307	ea_cache_entry *r = p;
308	308	p = p->next;
309	309	eaccelerator_mm_instance->hash_cnt--;
…	…
320	320	}
321	321	for (i = 0; i < EA_USER_HASH_SIZE; i++) {
322		mm_user_cache_entry *p = eaccelerator_mm_instance->user_hash[i];
	322	ea_user_cache_entry *p = eaccelerator_mm_instance->user_hash[i];
323	323	while (p != NULL) {
324		mm_user_cache_entry *r = p;
	324	ea_user_cache_entry *r = p;
325	325	p = p->next;
326	326	eaccelerator_mm_instance->user_hash_cnt--;
…	…
348	348
349	349	if (eaccelerator_mm_instance != NULL) {
350		mm_cache_entry p, q;
	350	ea_cache_entry p, q;
351	351	EACCELERATOR_UNPROTECT();
352	352	EACCELERATOR_LOCK_RW();
…	…
406	406	PHP_FUNCTION(eaccelerator_cached_scripts)
407	407	{
408		mm_cache_entry *p;
	408	ea_cache_entry *p;
409	409	int i;
410	410
…	…
439	439	PHP_FUNCTION(eaccelerator_removed_scripts)
440	440	{
441		mm_cache_entry *p;
	441	ea_cache_entry *p;
442	442	zval *script;
443	443

eaccelerator/trunk/ea_restore.c

r251	r254
158	158	}
159	159
160		void fixup_op_array(ea~~ccelerator~~_op_array * from TSRMLS_DC)
	160	void fixup_op_array(ea_op_array * from TSRMLS_DC)
161	161	{
162	162	zend_op *opline;
…	…
242	242	}
243	243
244		void fixup_class_entry(ea~~ccelerator~~_class_entry * from TSRMLS_DC)
	244	void fixup_class_entry(ea_class_entry * from TSRMLS_DC)
245	245	{
246	246	FIXUP(from->name);
…	…
393	393	}
394	394
395		zend_op_array restore_op_array(zend_op_array to,
396		eaccelerator_op_array * from TSRMLS_DC)
	395	zend_op_array restore_op_array(zend_op_array to, ea_op_array * from TSRMLS_DC)
397	396	{
398	397	union {
…	…
618	617	}
619	618
620		static zend_op_array restore_op_array_ptr(eaccelerator_op_array
621		from TSRMLS_DC)
	619	static zend_op_array restore_op_array_ptr(ea_op_array from TSRMLS_DC)
622	620	{
623	621	return restore_op_array(NULL, from TSRMLS_CC);
…	…
735	733	#endif
736	734
737		zend_class_entry restore_class_entry(zend_class_entry to,
738		eaccelerator_class_entry * from TSRMLS_DC)
	735	zend_class_entry restore_class_entry(zend_class_entry to, ea_class_entry * from TSRMLS_DC)
739	736	{
740	737	zend_class_entry *old;
…	…
844	841	}
845	842
846		restore_hash(&to->function_table, &from->function_table,
847		(restore_bucket_t) restore_op_array_ptr TSRMLS_CC);
	843	restore_hash(&to->function_table, &from->function_table, (restore_bucket_t)restore_op_array_ptr TSRMLS_CC);
848	844	to->function_table.pDestructor = ZEND_FUNCTION_DTOR;
849	845
…	…
861	857	}
862	858
863		void restore_function(mm_fc_entry * p TSRMLS_DC)
	859	void restore_function(ea_fc_entry * p TSRMLS_DC)
864	860	{
865	861	zend_op_array op_array;
…	…
868	864	return;
869	865	}
870		if (restore_op_array(&op_array, (ea~~ccelerator~~_op_array *) p->fc TSRMLS_CC) != NULL) {
	866	if (restore_op_array(&op_array, (ea_op_array *) p->fc TSRMLS_CC) != NULL) {
871	867	if (zend_hash_add(CG(function_table), p->htabkey, p->htablen, &op_array, sizeof(zend_op_array), NULL) == FAILURE) {
872	868	CG(in_compilation) = 1;
…	…
885	881	* Class handling.
886	882	*/
887		void restore_class(mm_fc_entry * p TSRMLS_DC)
	883	void restore_class(ea_fc_entry * p TSRMLS_DC)
888	884	{
889	885	#ifdef ZEND_ENGINE_2
…	…
897	893	}
898	894	#ifdef ZEND_ENGINE_2
899		ce = restore_class_entry(NULL, (ea~~ccelerator~~_class_entry *) p->fc TSRMLS_CC);
	895	ce = restore_class_entry(NULL, (ea_class_entry *) p->fc TSRMLS_CC);
900	896	if (ce != NULL)
901	897	#else
902		if (restore_class_entry(&ce, (ea~~ccelerator~~_class_entry *) p->fc TSRMLS_CC) != NULL)
	898	if (restore_class_entry(&ce, (ea_class_entry *) p->fc TSRMLS_CC) != NULL)
903	899	#endif
904	900	{

eaccelerator/trunk/ea_restore.h

r183	r254
30	30
31	31	#define FIXUP(x) if((x)!=NULL) {(x) = (void)(((char)(x)) + ((long)(EAG(mem))));}
32		void fixup_op_array(ea~~ccelerator~~_op_array *from TSRMLS_DC);
33		void fixup_class_entry(ea~~ccelerator~~_class_entry *from TSRMLS_DC);
	32	void fixup_op_array(ea_op_array *from TSRMLS_DC);
	33	void fixup_class_entry(ea_class_entry *from TSRMLS_DC);
34	34	void fixup_zval(zval *z TSRMLS_DC);
35	35
36	36	void restore_zval(zval *zv TSRMLS_DC);
37		void restore_class(mm_fc_entry *p TSRMLS_DC);
38		void restore_function(mm_fc_entry *p TSRMLS_DC);
39		zend_op_array* restore_op_array(zend_op_array to, ea~~ccelerator~~_op_array from TSRMLS_DC);
40		zend_class_entry restore_class_entry(zend_class_entry to, ea~~ccelerator~~_class_entry *from TSRMLS_DC);
	37	void restore_class(ea_fc_entry *p TSRMLS_DC);
	38	void restore_function(ea_fc_entry *p TSRMLS_DC);
	39	zend_op_array* restore_op_array(zend_op_array to, ea_op_array from TSRMLS_DC);
	40	zend_class_entry restore_class_entry(zend_class_entry to, ea_class_entry *from TSRMLS_DC);
41	41	void restore_class_parent(char parent, int len, zend_class_entry to TSRMLS_DC);
42	42	#ifdef ZEND_ENGINE_2

eaccelerator/trunk/ea_store.c

r248	r254
146	146	} else if (from->type == ZEND_USER_FUNCTION) {
147	147	EACCELERATOR_ALIGN(EAG(mem));
148		EAG(mem) += sizeof(ea~~ccelerator~~_op_array);
	148	EAG(mem) += sizeof(ea_op_array);
149	149	} else {
150	150	DBG(ea_debug_error, ("[%d] EACCELERATOR can't cache function \"%s\"\n", getpid(), from->function_name));
…	…
241	241	}
242	242	EACCELERATOR_ALIGN(EAG(mem));
243		EAG(mem) += sizeof(ea~~ccelerator~~_class_entry);
	243	EAG(mem) += sizeof(ea_class_entry);
244	244
245	245	if (from->name != NULL)
…	…
284	284
285	285	zend_hash_init(&EAG(strings), 0, NULL, NULL, 0);
286		EAG(mem) += offsetof(mm_cache_entry, realfilename) + len + 1;
	286	EAG(mem) += offsetof(ea_cache_entry, realfilename) + len + 1;
287	287	zend_hash_add(&EAG(strings), key, len + 1, &key, sizeof(char *), NULL);
288	288	b = c;
289	289	while (b != NULL) {
290	290	EACCELERATOR_ALIGN(EAG(mem));
291		EAG(mem) += offsetof(mm_fc_entry, htabkey) + b->nKeyLength;
	291	EAG(mem) += offsetof(ea_fc_entry, htabkey) + b->nKeyLength;
292	292	x = b->arKey;
293	293	zend_hash_add(&EAG(strings), b->arKey, b->nKeyLength, &x, sizeof(char *), NULL);
…	…
297	297	while (b != NULL) {
298	298	EACCELERATOR_ALIGN(EAG(mem));
299		EAG(mem) += offsetof(mm_fc_entry, htabkey) + b->nKeyLength;
	299	EAG(mem) += offsetof(ea_fc_entry, htabkey) + b->nKeyLength;
300	300	x = b->arKey;
301	301	zend_hash_add(&EAG(strings), b->arKey, b->nKeyLength, &x, sizeof(char *), NULL);
…	…
473	473	}
474	474
475		ea~~ccelerator~~_op_array store_op_array(zend_op_array from TSRMLS_DC)
476		{
477		ea~~ccelerator~~_op_array *to;
	475	ea_op_array store_op_array(zend_op_array from TSRMLS_DC)
	476	{
	477	ea_op_array *to;
478	478	zend_op *opline;
479	479	zend_op *end;
…	…
496	496	if (from->type == ZEND_INTERNAL_FUNCTION) {
497	497	EACCELERATOR_ALIGN(EAG(mem));
498		to = (ea~~ccelerator~~_op_array *) EAG(mem);
499		EAG(mem) += offsetof(ea~~ccelerator~~_op_array, opcodes);
	498	to = (ea_op_array *) EAG(mem);
	499	EAG(mem) += offsetof(ea_op_array, opcodes);
500	500	} else if (from->type == ZEND_USER_FUNCTION) {
501	501	EACCELERATOR_ALIGN(EAG(mem));
502		to = (ea~~ccelerator~~_op_array *) EAG(mem);
503		EAG(mem) += sizeof(ea~~ccelerator~~_op_array);
	502	to = (ea_op_array *) EAG(mem);
	503	EAG(mem) += sizeof(ea_op_array);
504	504	} else {
505	505	return NULL;
…	…
785	785	#endif
786	786
787		ea~~ccelerator~~_class_entry store_class_entry(zend_class_entry from TSRMLS_DC)
788		{
789		ea~~ccelerator~~_class_entry *to;
	787	ea_class_entry store_class_entry(zend_class_entry from TSRMLS_DC)
	788	{
	789	ea_class_entry *to;
790	790	unsigned int i;
791	791
792	792	EACCELERATOR_ALIGN(EAG(mem));
793		to = (ea~~ccelerator~~_class_entry *) EAG(mem);
794		EAG(mem) += sizeof(ea~~ccelerator~~_class_entry);
	793	to = (ea_class_entry *) EAG(mem);
	794	EAG(mem) += sizeof(ea_class_entry);
795	795	to->type = from->type;
796	796	to->name = NULL;

eaccelerator/trunk/ea_store.h

r183	r254
35	35
36	36	void store_zval(zval *z TSRMLS_DC);
37		ea~~ccelerator~~_op_array store_op_array(zend_op_array from TSRMLS_DC);
38		ea~~ccelerator~~_class_entry store_class_entry_ptr(zend_class_entry *from TSRMLS_DC);
39		ea~~ccelerator~~_class_entry store_class_entry(zend_class_entry from TSRMLS_DC);
	37	ea_op_array store_op_array(zend_op_array from TSRMLS_DC);
	38	ea_class_entry store_class_entry_ptr(zend_class_entry *from TSRMLS_DC);
	39	ea_class_entry store_class_entry(zend_class_entry from TSRMLS_DC);
40	40
41	41	#endif /* EA_STORE_H */

eaccelerator/trunk/eaccelerator.c

r253	r254
80	80
81	81	/* Globals (common for each process/thread) */
82		static long ea~~ccelerator~~_shm_size = 0;
83		long ea~~ccelerator~~_shm_max = 0;
84		static long ea~~ccelerator~~_shm_ttl = 0;
85		static long ea~~ccelerator~~_shm_prune_period = 0;
	82	static long ea_shm_size = 0;
	83	long ea_shm_max = 0;
	84	static long ea_shm_ttl = 0;
	85	static long ea_shm_prune_period = 0;
86	86	extern long eaccelerator_debug;
87	87	static zend_bool eaccelerator_check_mtime = 1;
…	…
122	122
123	123	/* Find a script entry with the given hash key */
124		static mm_cache_entry* hash_find_mm(const char *key,
	124	static ea_cache_entry* hash_find_mm(const char *key,
125	125	struct stat *buf,
126	126	int *nreloads,
127	127	time_t ttl) {
128	128	unsigned int hv, slot;
129		mm_cache_entry p, q;
	129	ea_cache_entry p, q;
130	130
131	131	#ifdef EACCELERATOR_USE_INODE
…	…
193	193
194	194	/* Add a new entry to the hashtable */
195		static void hash_add_mm(mm_cache_entry *x) {
196		mm_cache_entry p,q;
	195	static void hash_add_mm(ea_cache_entry *x) {
	196	ea_cache_entry p,q;
197	197	unsigned int slot;
198	198	#ifdef EACCELERATOR_USE_INODE
…	…
247	247	char mm_path[MAXPATHLEN];
248	248
249		~~/* if (getppid() != 1) return SUCCESS; / /???*/~~
250	249	#ifdef ZEND_WIN32
251	250	snprintf(mm_path, MAXPATHLEN, "%s.%s", EACCELERATOR_MM_FILE, sapi_module.name);
252	251	#else
253		snprintf(mm_path, MAXPATHLEN, "%s.%s%d", EACCELERATOR_MM_FILE, sapi_module.name, ~~getpid()~~);
	252	snprintf(mm_path, MAXPATHLEN, "%s.%s%d", EACCELERATOR_MM_FILE, sapi_module.name, owner);
254	253	#endif
255	254	/* snprintf(mm_path, MAXPATHLEN, "%s.%s%d", EACCELERATOR_MM_FILE, sapi_module.name, geteuid());*/
256		if ((eaccelerator_mm_instance = (eaccelerator_mm)mm_attach(ea~~ccelerator~~_shm_size1024*1024, mm_path)) != NULL) {
	255	if ((eaccelerator_mm_instance = (eaccelerator_mm)mm_attach(ea_shm_size1024*1024, mm_path)) != NULL) {
257	256	#ifdef ZTS
258	257	ea_mutex = tsrm_mutex_alloc();
…	…
260	259	return SUCCESS;
261	260	}
262		mm = mm_create(ea~~ccelerator~~_shm_size10241024, mm_path);
	261	mm = mm_create(ea_shm_size10241024, mm_path);
263	262	if (!mm) {
264	263	return FAILURE;
265	264	}
266	265	#ifdef ZEND_WIN32
267		DBG(ea_debug_printf, (EA_DEBUG, "init_mm [%d]\n", ~~getpid()~~));
268		#else
269		DBG(ea_debug_printf, (EA_DEBUG, "init_mm [%d,%d]\n", ~~getpid()~~, getppid()));
	266	DBG(ea_debug_printf, (EA_DEBUG, "init_mm [%d]\n", owner));
	267	#else
	268	DBG(ea_debug_printf, (EA_DEBUG, "init_mm [%d,%d]\n", owner, getppid()));
270	269	#endif
271	270	#ifdef ZTS
…	…
444	443	eaccelerator_mm_instance->last_prune = t;
445	444	for (i = 0; i < EA_HASH_SIZE; i++) {
446		mm_cache_entry **p = &eaccelerator_mm_instance->hash[i];
	445	ea_cache_entry **p = &eaccelerator_mm_instance->hash[i];
447	446	while (*p != NULL) {
448	447	struct stat buf;
…	…
455	454	(*p)->mtime != buf.st_mtime \|\|
456	455	(*p)->filesize != buf.st_size) {
457		mm_cache_entry r = p;
	456	ea_cache_entry r = p;
458	457	p = (p)->next;
459	458	eaccelerator_mm_instance->hash_cnt--;
…	…
478	477	}
479	478	}
480		if (ea~~ccelerator~~_shm_prune_period > 0) {
	479	if (ea_shm_prune_period > 0) {
481	480	t = time(0);
482		if (t - eaccelerator_mm_instance->last_prune > ea~~ccelerator~~_shm_prune_period) {
	481	if (t - eaccelerator_mm_instance->last_prune > ea_shm_prune_period) {
483	482	eaccelerator_prune(t);
484	483	p = eaccelerator_malloc(size);
…	…
565	564	}
566	565
567		void eaccelerator_fixup (mm_cache_entry * p TSRMLS_DC)
	566	void eaccelerator_fixup (ea_cache_entry * p TSRMLS_DC)
568	567	{
569		mm_fc_entry *q;
	568	ea_fc_entry *q;
570	569
571	570	EAG (mem) = (char *) ((long) p - (long) p->next);
…	…
579	578	while (q != NULL) {
580	579	FIXUP (q->fc);
581		fixup_op_array ((ea~~ccelerator~~_op_array *) q->fc TSRMLS_CC);
	580	fixup_op_array ((ea_op_array *) q->fc TSRMLS_CC);
582	581	FIXUP (q->next);
583	582	q = q->next;
…	…
586	585	while (q != NULL) {
587	586	FIXUP (q->fc);
588		fixup_class_entry ((ea~~ccelerator~~_class_entry *) q->fc TSRMLS_CC);
	587	fixup_class_entry ((ea_class_entry *) q->fc TSRMLS_CC);
589	588	FIXUP (q->next);
590	589	q = q->next;
…	…
597	596
598	597	/* Retrieve a cache entry from the cache directory */
599		static mm_cache_entry* hash_find_file(const char *key,
	598	static ea_cache_entry* hash_find_file(const char *key,
600	599	struct stat *buf TSRMLS_DC) {
601	600	int f;
602	601	char s[MAXPATHLEN];
603		mm_file_header hdr;
604		mm_cache_entry *p;
	602	ea_file_header hdr;
	603	ea_cache_entry *p;
605	604	int use_shm = 1;
606	605
…	…
686	685	p->use_cnt = 1;
687	686	p->removed = 0;
688		if (ea~~ccelerator~~_shm_ttl > 0) {
689		p->ttl = time(0) + ea~~ccelerator~~_shm_ttl;
	687	if (ea_shm_ttl > 0) {
	688	p->ttl = time(0) + ea_shm_ttl;
690	689	} else {
691	690	p->ttl = 0;
…	…
702	701
703	702	/* Add a cache entry to the cache directory */
704		static int hash_add_file(mm_cache_entry *p TSRMLS_DC) {
	703	static int hash_add_file(ea_cache_entry *p TSRMLS_DC) {
705	704	int f;
706	705	int ret = 0;
707	706	char s[MAXPATHLEN];
708		mm_file_header hdr;
	707	ea_file_header hdr;
709	708
710	709	#ifdef EACCELERATOR_USE_INODE
…	…
742	741	/* Create a cache entry from the given op_array, functions and classes of a
743	742	script */
744		static mm_cache_entry eaccelerator_store_int (char key, int len,
	743	static ea_cache_entry eaccelerator_store_int (char key, int len,
745	744	zend_op_array * op_array, Bucket * f, Bucket * c TSRMLS_DC)
746	745	{
747		mm_cache_entry *p;
748		mm_fc_entry *fc;
749		mm_fc_entry *q;
	746	ea_cache_entry *p;
	747	ea_fc_entry *fc;
	748	ea_fc_entry *q;
750	749	char *x;
751	750
…	…
756	755	EAG (compress) = 1;
757	756	zend_hash_init (&EAG (strings), 0, NULL, NULL, 0);
758		p = (mm_cache_entry *) EAG (mem);
759		EAG (mem) += offsetof (mm_cache_entry, realfilename) + len + 1;
	757	p = (ea_cache_entry *) EAG (mem);
	758	EAG (mem) += offsetof (ea_cache_entry, realfilename) + len + 1;
760	759
761	760	p->nhits = 0;
…	…
776	775
777	776	EACCELERATOR_ALIGN (EAG (mem));
778		fc = (mm_fc_entry *) EAG (mem);
779		EAG (mem) += offsetof (mm_fc_entry, htabkey) + c->nKeyLength;
	777	fc = (ea_fc_entry *) EAG (mem);
	778	EAG (mem) += offsetof (ea_fc_entry, htabkey) + c->nKeyLength;
780	779	memcpy (fc->htabkey, c->arKey, c->nKeyLength);
781	780	fc->htablen = c->nKeyLength;
…	…
805	804
806	805	EACCELERATOR_ALIGN (EAG (mem));
807		fc = (mm_fc_entry *) EAG (mem);
808		EAG (mem) += offsetof (mm_fc_entry, htabkey) + f->nKeyLength;
	806	fc = (ea_fc_entry *) EAG (mem);
	807	EAG (mem) += offsetof (ea_fc_entry, htabkey) + f->nKeyLength;
809	808	memcpy (fc->htabkey, f->arKey, f->nKeyLength);
810	809	fc->htablen = f->nKeyLength;
…	…
845	844	zend_op_array* op_array,
846	845	Bucket* f, Bucket *c TSRMLS_DC) {
847		mm_cache_entry *p;
	846	ea_cache_entry *p;
848	847	int len = strlen(key);
849	848	int use_shm = 1;
…	…
882	881	#endif
883	882	if (use_shm) {
884		if (ea~~ccelerator~~_shm_ttl > 0) {
885		p->ttl = time(0) + ea~~ccelerator~~_shm_ttl;
	883	if (ea_shm_ttl > 0) {
	884	p->ttl = time(0) + ea_shm_ttl;
886	885	} else {
887	886	p->ttl = 0;
…	…
905	904	static zend_op_array* eaccelerator_restore(char realname, struct stat buf,
906	905	int *nreloads, time_t compile_time TSRMLS_DC) {
907		mm_cache_entry *p;
	906	ea_cache_entry *p;
908	907	zend_op_array *op_array = NULL;
909	908
910	909	*nreloads = 1;
911	910	EACCELERATOR_UNPROTECT();
912		p = hash_find_mm(realname, buf, nreloads, ((ea~~ccelerator_shm_ttl > 0)?(compile_time + eaccelerator~~_shm_ttl):0));
	911	p = hash_find_mm(realname, buf, nreloads, ((ea_shm_ttl > 0)?(compile_time + ea_shm_ttl):0));
913	912	if (p == NULL && !eaccelerator_scripts_shm_only) {
914	913	p = hash_find_file(realname, buf TSRMLS_CC);
…	…
919	918	op_array = restore_op_array(NULL, p->op_array TSRMLS_CC);
920	919	if (op_array != NULL) {
921		mm_fc_entry *e;
922		~~mm_used_entry *used = emalloc(sizeof(mm~~_used_entry));
	920	ea_fc_entry *e;
	921	ea_used_entry *used = emalloc(sizeof(ea_used_entry));
923	922	used->entry = p;
924		used->next = (mm_used_entry*)EAG(used_entries);
	923	used->next = (ea_used_entry*)EAG(used_entries);
925	924	EAG(used_entries) = (void*)used;
926	925	EAG(mem) = op_array->filename;
…	…
1018	1017	/* Check if the file is ok to cache */
1019	1018	static int eaccelerator_ok_to_cache(char *realname TSRMLS_DC) {
1020		mm_cond_entry *p;
	1019	ea_cond_entry *p;
1021	1020	int ok;
1022	1021	if (EAG(cond_list) == NULL) {
…	…
1590	1589	*/
1591	1590	PHP_INI_MH(eaccelerator_filter) {
1592		mm_cond_entry p, q;
	1591	ea_cond_entry p, q;
1593	1592	char *s = new_value;
1594	1593	char *ss;
…	…
1617	1616	;
1618	1617	if ((s > ss) && *ss) {
1619		p = (~~mm_cond_entry *)malloc(sizeof(mm~~_cond_entry));
	1618	p = (ea_cond_entry *)malloc(sizeof(ea_cond_entry));
1620	1619	if (p == NULL)
1621	1620	break;
…	…
1657	1656	STD_PHP_INI_ENTRY("eaccelerator.compress", "1", PHP_INI_ALL, OnUpdateBool, compression_enabled, zend_eaccelerator_globals, eaccelerator_globals)
1658	1657	STD_PHP_INI_ENTRY("eaccelerator.compress_level", "9", PHP_INI_ALL, OnUpdateLong, compress_level, zend_eaccelerator_globals, eaccelerator_globals)
1659		ZEND_INI_ENTRY1("eaccelerator.shm_size", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea~~ccelerator~~_shm_size)
1660		ZEND_INI_ENTRY1("eaccelerator.shm_max", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea~~ccelerator~~_shm_max)
1661		ZEND_INI_ENTRY1("eaccelerator.shm_ttl", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea~~ccelerator~~_shm_ttl)
1662		ZEND_INI_ENTRY1("eaccelerator.shm_prune_period", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea~~ccelerator~~_shm_prune_period)
	1658	ZEND_INI_ENTRY1("eaccelerator.shm_size", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_size)
	1659	ZEND_INI_ENTRY1("eaccelerator.shm_max", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_max)
	1660	ZEND_INI_ENTRY1("eaccelerator.shm_ttl", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_ttl)
	1661	ZEND_INI_ENTRY1("eaccelerator.shm_prune_period", "0", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &ea_shm_prune_period)
1663	1662	ZEND_INI_ENTRY1("eaccelerator.debug", "1", PHP_INI_SYSTEM, eaccelerator_OnUpdateLong, &eaccelerator_debug)
1664	1663	STD_PHP_INI_ENTRY("eaccelerator.log_file", "", PHP_INI_SYSTEM, OnUpdateString, eaccelerator_log_file, zend_eaccelerator_globals, eaccelerator_globals)
…	…
1683	1682
1684	1683	static void eaccelerator_clean_request(TSRMLS_D) {
1685		~~mm_used_entry p = (mm~~_used_entry)EAG(used_entries);
	1684	ea_used_entry p = (ea_used_entry)EAG(used_entries);
1686	1685	if (eaccelerator_mm_instance != NULL) {
1687	1686	EACCELERATOR_UNPROTECT();
…	…
1698	1697	p->entry = NULL;
1699	1698	} else {
1700		mm_cache_entry *q = eaccelerator_mm_instance->removed;
	1699	ea_cache_entry *q = eaccelerator_mm_instance->removed;
1701	1700	while (q != NULL && q->next != p->entry) {
1702	1701	q = q->next;
…	…
1717	1716	THREAD_T thread = tsrm_thread_id();
1718	1717	#endif
1719		mm_lock_entry** p = &eaccelerator_mm_instance->locks;
	1718	ea_lock_entry** p = &eaccelerator_mm_instance->locks;
1720	1719	while ((*p) != NULL) {
1721	1720	#ifdef ZTS
…	…
1724	1723	if ((*p)->pid == pid) {
1725	1724	#endif
1726		mm_lock_entry* x = *p;
	1725	ea_lock_entry* x = *p;
1727	1726	p = (p)->next;
1728	1727	eaccelerator_free_nolock(x);
…	…
1735	1734	}
1736	1735	EACCELERATOR_PROTECT();
1737		p = (mm_used_entry*)EAG(used_entries);
	1736	p = (ea_used_entry*)EAG(used_entries);
1738	1737	while (p != NULL) {
1739		mm_used_entry* r = p;
	1738	ea_used_entry* r = p;
1740	1739	p = p->next;
1741	1740	if (r->entry != NULL && r->entry->use_cnt < 0) {
…	…
1856	1855	static void eaccelerator_globals_dtor(zend_eaccelerator_globals *eaccelerator_globals)
1857	1856	{
1858		mm_cond_entry p, q;
	1857	ea_cond_entry p, q;
1859	1858
1860	1859	for (p = eaccelerator_globals->cond_list; p != NULL; p = q) {
…	…
1927	1926	REGISTER_INI_ENTRIES();
1928	1927	REGISTER_STRING_CONSTANT("EACCELERATOR_VERSION", EACCELERATOR_VERSION, CONST_CS \| CONST_PERSISTENT);
1929		REGISTER_LONG_CONSTANT("EACCELERATOR_SHM_AND_DISK", ea~~ccelerator~~_shm_and_disk, CONST_CS \| CONST_PERSISTENT);
1930		REGISTER_LONG_CONSTANT("EACCELERATOR_SHM", ea~~ccelerator~~_shm, CONST_CS \| CONST_PERSISTENT);
1931		REGISTER_LONG_CONSTANT("EACCELERATOR_SHM_ONLY", ea~~ccelerator~~_shm_only, CONST_CS \| CONST_PERSISTENT);
1932		REGISTER_LONG_CONSTANT("EACCELERATOR_DISK_ONLY", ea~~ccelerator~~_disk_only, CONST_CS \| CONST_PERSISTENT);
1933		REGISTER_LONG_CONSTANT("EACCELERATOR_NONE", ea~~ccelerator~~_none, CONST_CS \| CONST_PERSISTENT);
	1928	REGISTER_LONG_CONSTANT("EACCELERATOR_SHM_AND_DISK", ea_shm_and_disk, CONST_CS \| CONST_PERSISTENT);
	1929	REGISTER_LONG_CONSTANT("EACCELERATOR_SHM", ea_shm, CONST_CS \| CONST_PERSISTENT);
	1930	REGISTER_LONG_CONSTANT("EACCELERATOR_SHM_ONLY", ea_shm_only, CONST_CS \| CONST_PERSISTENT);
	1931	REGISTER_LONG_CONSTANT("EACCELERATOR_DISK_ONLY", ea_disk_only, CONST_CS \| CONST_PERSISTENT);
	1932	REGISTER_LONG_CONSTANT("EACCELERATOR_NONE", ea_none, CONST_CS \| CONST_PERSISTENT);
1934	1933	binary_eaccelerator_version = encode_version(EACCELERATOR_VERSION);
1935	1934	binary_php_version = encode_version(PHP_VERSION);

eaccelerator/trunk/eaccelerator.h

r253	r254
52	52	/* fixes compile errors on php5.1 */
53	53	#ifdef STR_EMPTY_ALLOC
54		#define empty_string STR_EMPTY_ALLOC()
	54	# define empty_string STR_EMPTY_ALLOC()
55	55	#endif
56	56
…	…
226	226	zend_uint line_end;
227	227	#endif
228		} ea~~ccelerator~~_op_array;
	228	} ea_op_array;
229	229
230	230	typedef struct _eaccelerator_class_entry {
…	…
249	249	zend_uint line_end;
250	250	#endif
251		} ea~~ccelerator~~_class_entry;
	251	} ea_class_entry;
252	252
253	253	/*
254	254	* To cache functions and classes.
255	255	*/
256		typedef struct _mm_fc_entry {
	256	typedef struct _ea_fc_entry {
257	257	void *fc;
258		struct _mm_fc_entry *next;
	258	struct _ea_fc_entry *next;
259	259	int htablen;
260	260	char htabkey[1]; /* must be last element */
261		} mm_fc_entry;
	261	} ea_fc_entry;
262	262
263	263
…	…
267	267	* into the list of mm_fc_entry.
268	268	*/
269		typedef struct _mm_cache_entry {
270		struct _mm_cache_entry *next;
	269	typedef struct _ea_cache_entry {
	270	struct _ea_cache_entry *next;
271	271	#ifdef EACCELERATOR_USE_INODE
272	272	dev_t st_dev; /* file's device */
…	…
282	282	int nreloads; /* count of reloads */
283	283	int use_cnt; /* how many processes uses the entry */
284		ea~~ccelerator~~_op_array op_array; / script's global scope code */
285		mm_fc_entry f_head; / list of nested functions */
286		mm_fc_entry c_head; / list of nested classes */
	284	ea_op_array op_array; / script's global scope code */
	285	ea_fc_entry f_head; / list of nested functions */
	286	ea_fc_entry c_head; / list of nested classes */
287	287	zend_bool removed; /* the entry is scheduled to remove */
288	288	char realfilename[1]; /* real file name (must be last el.) */
289		} mm_cache_entry;
	289	} ea_cache_entry;
290	290
291	291	/*
292	292	* bucket for user's cache
293	293	*/
294		typedef struct _mm_user_cache_entry {
295		struct _mm_user_cache_entry *next;
	294	typedef struct _ea_user_cache_entry {
	295	struct _ea_user_cache_entry *next;
296	296	unsigned int hv; /* hash value */
297	297	long ttl; /* expiration time */
…	…
300	300	zval value; /* value */
301	301	char key[1]; /* key value (must be last el) */
302		} mm_user_cache_entry;
	302	} ea_user_cache_entry;
303	303
304	304	/*
305	305	* Linked list of mm_cache_entry which are used by process/thread
306	306	*/
307		typedef struct _mm_used_entry {
308		struct _mm_used_entry *next;
309		mm_cache_entry *entry;
310		} mm_used_entry;
	307	typedef struct _ea_used_entry {
	308	struct _ea_used_entry *next;
	309	ea_cache_entry *entry;
	310	} ea_used_entry;
311	311
312	312	/*
313	313	* Linked list of locks
314	314	*/
315		typedef struct _mm_lock_entry {
316		struct _mm_lock_entry *next;
	315	typedef struct _ea_lock_entry {
	316	struct _ea_lock_entry *next;
317	317	pid_t pid;
318	318	#ifdef ZTS
…	…
320	320	#endif
321	321	char key[1];
322		} mm_lock_entry;
323
324		typedef struct _mm_file_header {
	322	} ea_lock_entry;
	323
	324	typedef struct _ea_file_header {
325	325	char magic[8]; /* "EACCELERATOR" */
326	326	int eaccelerator_version;
…	…
330	330	time_t mtime;
331	331	unsigned int crc32;
332		} mm_file_header;
	332	} ea_file_header;
333	333
334	334	typedef struct {
…	…
342	342	unsigned int rem_cnt;
343	343	time_t last_prune;
344		mm_cache_entry *removed;
345		mm_lock_entry *locks;
346
347		mm_cache_entry *hash[EA_HASH_SIZE];
348		mm_user_cache_entry *user_hash[EA_USER_HASH_SIZE];
	344	ea_cache_entry *removed;
	345	ea_lock_entry *locks;
	346
	347	ea_cache_entry *hash[EA_HASH_SIZE];
	348	ea_user_cache_entry *user_hash[EA_USER_HASH_SIZE];
349	349	} eaccelerator_mm;
350	350
…	…
352	352	* Where to cache
353	353	*/
354		typedef enum _ea~~ccelerator~~_cache_place {
355		ea~~ccelerator~~_shm_and_disk, /* in shm and in disk */
356		ea~~ccelerator_shm,~~ /* in shm, but if it is not possible then on disk */
357		ea~~ccelerator~~_shm_only, /* in shm only */
358		ea~~ccelerator~~_disk_only, /* on disk only */
359		ea~~ccelerator_none~~ /* don't cache */
360		} ea~~ccelerator~~_cache_place;
	354	typedef enum _ea_cache_place {
	355	ea_shm_and_disk, /* in shm and in disk */
	356	ea_shm, /* in shm, but if it is not possible then on disk */
	357	ea_shm_only, /* in shm only */
	358	ea_disk_only, /* on disk only */
	359	ea_none /* don't cache */
	360	} ea_cache_place;
361	361
362	362	typedef union align_union {
…	…
415	415	* conditional filter
416	416	*/
417		typedef struct _mm_cond_entry {
	417	typedef struct _ea_cond_entry {
418	418	char *str;
419	419	int len;
420	420	zend_bool not;
421		struct _mm_cond_entry *next;
422		} mm_cond_entry;
	421	struct _ea_cond_entry *next;
	422	} ea_cond_entry;
423	423
424	424	/*
…	…
445	445	HashTable restored;
446	446	zend_class_entry *class_entry;
447		mm_cond_entry *cond_list;
	447	ea_cond_entry *cond_list;
448	448	zend_uint refcount_helper;
449	449	char hostname[32];

eaccelerator/trunk/session.c

r228	r254
43	43	#endif
44	44
45		eaccelerator_cache_place eaccelerator_sessions_cache_place =
46		eaccelerator_shm_and_disk;
	45	ea_cache_place eaccelerator_sessions_cache_place = ea_shm_and_disk;
47	46	int eaccelerator_sessions_registered = 0;
48	47	extern eaccelerator_mm *eaccelerator_mm_instance;
…	…
51	50	PHP_INI_MH(eaccelerator_OnUpdateSessionCachePlace)
52	51	{
53		if (strncasecmp("shm_and_disk", new_value, sizeof ("shm_and_disk")) == 0) {
54		eaccelerator_sessions_cache_place = ea~~ccelerator~~_shm_and_disk;
	52	if (strncasecmp("shm_and_disk", new_value, sizeof("shm_and_disk")) == 0) {
	53	eaccelerator_sessions_cache_place = ea_shm_and_disk;
55	54	} else if (strncasecmp("shm", new_value, sizeof ("shm")) == 0) {
56		eaccelerator_sessions_cache_place = ea~~ccelerator~~_shm;
	55	eaccelerator_sessions_cache_place = ea_shm;
57	56	} else if (strncasecmp("shm_only", new_value, sizeof ("shm_only")) == 0) {
58		eaccelerator_sessions_cache_place = ea~~ccelerator~~_shm_only;
	57	eaccelerator_sessions_cache_place = ea_shm_only;
59	58	} else if (strncasecmp("disk_only", new_value, sizeof ("disk_only")) == 0) {
60		eaccelerator_sessions_cache_place = ea~~ccelerator~~_disk_only;
	59	eaccelerator_sessions_cache_place = ea_disk_only;
61	60	} else if (strncasecmp("none", new_value, sizeof ("none")) == 0) {
62		eaccelerator_sessions_cache_place = ea~~ccelerator~~_none;
	61	eaccelerator_sessions_cache_place = ea_none;
63	62	}
64	63	return SUCCESS;
…	…
381	380	int eaccelerator_session_registered()
382	381	{
383		return !(eaccelerator_sessions_cache_place != eaccelerator_none &&
384		eaccelerator_sessions_registered == 0);
	382	return !(eaccelerator_sessions_cache_place != ea_none && eaccelerator_sessions_registered == 0);
385	383	}
386	384
…	…
401	399	zval param;
402	400	zval *params[1];
403		/*
404		if (php_session_register_module(&ps_mod_eaccelerator) != 0) {
405		return 0;
406		}
407		*/
408		if (eaccelerator_sessions_cache_place == eaccelerator_none) {
	401
	402	if (eaccelerator_sessions_cache_place == ea_none) {
409	403	return 0;
410	404	}

eaccelerator/trunk/shm.c

r249	r254
41	41
42	42	/* where to cache the keys */
43		eaccelerator_cache_place eaccelerator_keys_cache_place =
44		eaccelerator_shm_and_disk;
	43	ea_cache_place eaccelerator_keys_cache_place = ea_shm_and_disk;
45	44
46	45	/* set the eaccelerator_keys_cache_place */
47		PHP_INI_MH (eaccelerator_OnUpdateKeysCachePlace)
	46	PHP_INI_MH(eaccelerator_OnUpdateKeysCachePlace)
48	47	{
49		if (strncasecmp ~~("shm_and_disk", new_value, sizeof~~ ("shm_and_disk")) == 0)
50		eaccelerator_keys_cache_place = ea~~ccelerator~~_shm_and_disk;
	48	if (strncasecmp("shm_and_disk", new_value, sizeof("shm_and_disk")) == 0)
	49	eaccelerator_keys_cache_place = ea_shm_and_disk;
51	50
52		else if (strncasecmp ~~("shm", new_value, sizeof~~ ("shm")) == 0)
53		eaccelerator_keys_cache_place = ea~~ccelerator~~_shm;
	51	else if (strncasecmp("shm", new_value, sizeof("shm")) == 0)
	52	eaccelerator_keys_cache_place = ea_shm;
54	53
55		else if (strncasecmp ("shm_only", new_value, sizeof ("shm_only")) == 0)
56		eaccelerator_keys_cache_place = ea~~ccelerator~~_shm_only;
	54	else if (strncasecmp("shm_only", new_value, sizeof ("shm_only")) == 0)
	55	eaccelerator_keys_cache_place = ea_shm_only;
57	56
58		else if (strncasecmp ~~("disk_only", new_value, sizeof~~ ("disk_only")) == 0)
59		eaccelerator_keys_cache_place = ea~~ccelerator~~_disk_only;
	57	else if (strncasecmp("disk_only", new_value, sizeof("disk_only")) == 0)
	58	eaccelerator_keys_cache_place = ea_disk_only;
60	59
61		else if (strncasecmp ~~("none", new_value, sizeof~~ ("none")) == 0)
62		eaccelerator_keys_cache_place = ea~~ccelerator~~_none;
	60	else if (strncasecmp("none", new_value, sizeof("none")) == 0)
	61	eaccelerator_keys_cache_place = ea_none;
63	62
64	63	return SUCCESS;

Navigation

Legend:

eaccelerator/trunk/ChangeLog

eaccelerator/trunk/cache.c

eaccelerator/trunk/cache.h

eaccelerator/trunk/content.c

eaccelerator/trunk/ea_dasm.c

eaccelerator/trunk/ea_info.c

eaccelerator/trunk/ea_restore.c

eaccelerator/trunk/ea_restore.h

eaccelerator/trunk/ea_store.c

eaccelerator/trunk/ea_store.h

eaccelerator/trunk/eaccelerator.c

eaccelerator/trunk/eaccelerator.h

eaccelerator/trunk/session.c

eaccelerator/trunk/shm.c

Download in other formats: