[asterisk-commits] russell: branch russell/frame_caching r41024 - in /team/russell/frame_caching...

asterisk-commits at lists.digium.com asterisk-commits at lists.digium.com
Thu Aug 24 17:19:17 MST 2006


Author: russell
Date: Thu Aug 24 19:19:16 2006
New Revision: 41024

URL: http://svn.digium.com/view/asterisk?rev=41024&view=rev
Log:
commit code that was in this branch before

Modified:
    team/russell/frame_caching/apps/app_milliwatt.c
    team/russell/frame_caching/apps/app_mixmonitor.c
    team/russell/frame_caching/channels/chan_iax2.c
    team/russell/frame_caching/channels/chan_local.c
    team/russell/frame_caching/channels/chan_zap.c
    team/russell/frame_caching/channels/iax2-parser.c
    team/russell/frame_caching/channels/iax2-parser.h
    team/russell/frame_caching/include/asterisk/channel.h
    team/russell/frame_caching/include/asterisk/chanspy.h
    team/russell/frame_caching/include/asterisk/frame.h
    team/russell/frame_caching/include/asterisk/slinfactory.h
    team/russell/frame_caching/main/abstract_jb.c
    team/russell/frame_caching/main/channel.c
    team/russell/frame_caching/main/frame.c
    team/russell/frame_caching/main/slinfactory.c
    team/russell/frame_caching/main/udptl.c

Modified: team/russell/frame_caching/apps/app_milliwatt.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/apps/app_milliwatt.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/apps/app_milliwatt.c (original)
+++ team/russell/frame_caching/apps/app_milliwatt.c Thu Aug 24 19:19:16 2006
@@ -66,10 +66,16 @@
 
 static int milliwatt_generate(struct ast_channel *chan, void *data, int len, int samples)
 {
-	struct ast_frame wf;
 	unsigned char buf[AST_FRIENDLY_OFFSET + 640];
 	const int maxsamples = sizeof (buf) / sizeof (buf[0]);
 	int i, *indexp = (int *) data;
+	struct ast_frame wf = {
+		.frametype = AST_FRAME_VOICE,
+		.subclass = AST_FORMAT_ULAW,
+		.offset = AST_FRIENDLY_OFFSET,
+		.data = buf + AST_FRIENDLY_OFFSET,
+		.src = __FUNCTION__,
+	};
 
 	/* Instead of len, use samples, because channel.c generator_force
 	* generate(chan, tmp, 0, 160) ignores len. In any case, len is
@@ -82,17 +88,8 @@
 		samples = maxsamples;
 	}
 	len = samples * sizeof (buf[0]);
-	wf.frametype = AST_FRAME_VOICE;
-	wf.subclass = AST_FORMAT_ULAW;
-	wf.offset = AST_FRIENDLY_OFFSET;
-	wf.mallocd = 0;
-	wf.data = buf + AST_FRIENDLY_OFFSET;
 	wf.datalen = len;
 	wf.samples = samples;
-	wf.src = "app_milliwatt";
-	wf.delivery.tv_sec = 0;
-	wf.delivery.tv_usec = 0;
-	wf.prev = wf.next = NULL;
 	/* create a buffer containing the digital milliwatt pattern */
 	for(i = 0; i < len; i++)
 	{

Modified: team/russell/frame_caching/apps/app_mixmonitor.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/apps/app_mixmonitor.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/apps/app_mixmonitor.c (original)
+++ team/russell/frame_caching/apps/app_mixmonitor.c Thu Aug 24 19:19:16 2006
@@ -191,7 +191,7 @@
 			   of frames if a queue flush was necessary, so process them
 			*/
 			for (; f; f = next) {
-				next = f->next;
+				next = AST_LIST_NEXT(f, frame_list);
 				if (write)
 					ast_writestream(mixmonitor->fs, f);
 				ast_frfree(f);

Modified: team/russell/frame_caching/channels/chan_iax2.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/channels/chan_iax2.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/channels/chan_iax2.c (original)
+++ team/russell/frame_caching/channels/chan_iax2.c Thu Aug 24 19:19:16 2006
@@ -621,11 +621,11 @@
 };
 
 static struct ast_iax2_queue {
-	struct iax_frame *head;
-	struct iax_frame *tail;
+	AST_LIST_HEAD(, iax_frame) queue;
 	int count;
-	ast_mutex_t lock;
-} iaxq;
+} iaxq = {
+	.queue = AST_LIST_HEAD_INIT_VALUE
+};
 
 static AST_LIST_HEAD_STATIC(users, iax2_user);
 
@@ -1071,11 +1071,12 @@
 
 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
 {
-	/* Malloc() a copy of a frame */
 	struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen);
 	if (new) {
-		memcpy(new, fr, sizeof(struct iax_frame));	
+		size_t mallocd_datalen = new->mallocd_datalen;
+		memcpy(new, fr, sizeof(*new));
 		iax_frame_wrap(new, &fr->af);
+		new->mallocd_datalen = mallocd_datalen;
 		new->data = NULL;
 		new->datalen = 0;
 		new->direction = DIRECTION_INGRESS;
@@ -1754,7 +1755,7 @@
 			ast_queue_hangup(owner);
 		}
 
-		for (cur = iaxq.head; cur ; cur = cur->next) {
+		AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
 			/* Cancel any pending transmissions */
 			if (cur->callno == pvt->callno) 
 				cur->retries = -1;
@@ -1875,17 +1876,10 @@
 	/* Do not try again */
 	if (freeme) {
 		/* Don't attempt delivery, just remove it from the queue */
-		ast_mutex_lock(&iaxq.lock);
-		if (f->prev) 
-			f->prev->next = f->next;
-		else
-			iaxq.head = f->next;
-		if (f->next)
-			f->next->prev = f->prev;
-		else
-			iaxq.tail = f->prev;
+		AST_LIST_LOCK(&iaxq.queue);
+		AST_LIST_REMOVE(&iaxq.queue, f, list);
 		iaxq.count--;
-		ast_mutex_unlock(&iaxq.lock);
+		AST_LIST_UNLOCK(&iaxq.queue);
 		f->retrans = -1;
 		/* Free the IAX frame */
 		iax2_frame_free(f);
@@ -2082,7 +2076,7 @@
 	int cnt = 0, dead=0, final=0;
 	if (argc != 3)
 		return RESULT_SHOWUSAGE;
-	for (cur = iaxq.head; cur ; cur = cur->next) {
+	AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
 		if (cur->retries < 0)
 			dead++;
 		if (cur->final)
@@ -2092,7 +2086,17 @@
 	ast_cli(fd, "    IAX Statistics\n");
 	ast_cli(fd, "---------------------\n");
 	ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
-	ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n", dead, final, cnt);
+	ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
+	
+	ast_cli(fd, "    IAX Frame Cache Statistics\n"
+			"---------------------------------------\n"
+			"Added to Cache:     %d\n"
+			"Removed from Cache: %d\n"
+			"Frames Allocated:   %d\n"
+			"Frames Freed        %d\n\n",
+			iax_get_added_to_cache(), iax_get_removed_from_cache(),
+			iax_get_frames_allocated(), iax_get_frames_freed());
+
 	return RESULT_SUCCESS;
 }
 
@@ -2369,24 +2373,13 @@
 static int iax2_transmit(struct iax_frame *fr)
 {
 	/* Lock the queue and place this packet at the end */
-	fr->next = NULL;
-	fr->prev = NULL;
 	/* By setting this to 0, the network thread will send it for us, and
 	   queue retransmission if necessary */
 	fr->sentyet = 0;
-	ast_mutex_lock(&iaxq.lock);
-	if (!iaxq.head) {
-		/* Empty queue */
-		iaxq.head = fr;
-		iaxq.tail = fr;
-	} else {
-		/* Double link */
-		iaxq.tail->next = fr;
-		fr->prev = iaxq.tail;
-		iaxq.tail = fr;
-	}
+	AST_LIST_LOCK(&iaxq.queue);
+	AST_LIST_INSERT_TAIL(&iaxq.queue, fr, list);
 	iaxq.count++;
-	ast_mutex_unlock(&iaxq.lock);
+	AST_LIST_UNLOCK(&iaxq.queue);
 	/* Wake up the network and scheduler thread */
 	pthread_kill(netthreadid, SIGURG);
 	signal_condition(&sched_lock, &sched_cond);
@@ -5328,15 +5321,15 @@
 	pvt->lastsent = 0;
 	pvt->nextpred = 0;
 	pvt->pingtime = DEFAULT_RETRY_TIME;
-	ast_mutex_lock(&iaxq.lock);
-	for (cur = iaxq.head; cur ; cur = cur->next) {
+	AST_LIST_LOCK(&iaxq.queue);
+	AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
 		/* We must cancel any packets that would have been transmitted
 		   because now we're talking to someone new.  It's okay, they
 		   were transmitted to someone that didn't care anyway. */
 		if (callno == cur->callno) 
 			cur->retries = -1;
 	}
-	ast_mutex_unlock(&iaxq.lock);
+	AST_LIST_UNLOCK(&iaxq.queue);
 	return 0; 
 }
 
@@ -5833,17 +5826,16 @@
 static void vnak_retransmit(int callno, int last)
 {
 	struct iax_frame *f;
-	ast_mutex_lock(&iaxq.lock);
-	f = iaxq.head;
-	while(f) {
+
+	AST_LIST_LOCK(&iaxq.queue);
+	AST_LIST_TRAVERSE(&iaxq.queue, f, list) {
 		/* Send a copy immediately */
 		if ((f->callno == callno) && iaxs[f->callno] &&
 			(f->oseqno >= last)) {
 			send_packet(f);
 		}
-		f = f->next;
-	}
-	ast_mutex_unlock(&iaxq.lock);
+	}
+	AST_LIST_UNLOCK(&iaxq.queue);
 }
 
 static void __iax2_poke_peer_s(void *data)
@@ -6568,8 +6560,8 @@
 					/* Ack the packet with the given timestamp */
 					if (option_debug && iaxdebug)
 						ast_log(LOG_DEBUG, "Cancelling transmission of packet %d\n", x);
-					ast_mutex_lock(&iaxq.lock);
-					for (cur = iaxq.head; cur ; cur = cur->next) {
+					AST_LIST_LOCK(&iaxq.queue);
+					AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
 						/* If it's our call, and our timestamp, mark -1 retries */
 						if ((fr->callno == cur->callno) && (x == cur->oseqno)) {
 							cur->retries = -1;
@@ -6581,7 +6573,7 @@
 							}
 						}
 					}
-					ast_mutex_unlock(&iaxq.lock);
+					AST_LIST_UNLOCK(&iaxq.queue);
 				}
 				/* Note how much we've received acknowledgement for */
 				if (iaxs[fr->callno])
@@ -6721,13 +6713,13 @@
 			case IAX_COMMAND_TXACC:
 				if (iaxs[fr->callno]->transferring == TRANSFER_BEGIN) {
 					/* Ack the packet with the given timestamp */
-					ast_mutex_lock(&iaxq.lock);
-					for (cur = iaxq.head; cur ; cur = cur->next) {
+					AST_LIST_LOCK(&iaxq.queue);
+					AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
 						/* Cancel any outstanding txcnt's */
 						if ((fr->callno == cur->callno) && (cur->transfer))
 							cur->retries = -1;
 					}
-					ast_mutex_unlock(&iaxq.lock);
+					AST_LIST_UNLOCK(&iaxq.queue);
 					memset(&ied1, 0, sizeof(ied1));
 					iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[fr->callno]->callno);
 					send_command(iaxs[fr->callno], AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied1.buf, ied1.pos, -1);
@@ -8029,49 +8021,42 @@
 	/* Our job is simple: Send queued messages, retrying if necessary.  Read frames 
 	   from the network, and queue them for delivery to the channels */
 	int res, count;
-	struct iax_frame *f, *freeme;
+	struct iax_frame *f;
+
 	if (timingfd > -1)
 		ast_io_add(io, timingfd, timing_read, AST_IO_IN | AST_IO_PRI, NULL);
+	
 	for(;;) {
 		/* Go through the queue, sending messages which have not yet been
 		   sent, and scheduling retransmissions if appropriate */
-		ast_mutex_lock(&iaxq.lock);
-		f = iaxq.head;
+		AST_LIST_LOCK(&iaxq.queue);
 		count = 0;
-		while(f) {
-			freeme = NULL;
-			if (!f->sentyet) {
-				f->sentyet++;
-				/* Send a copy immediately -- errors here are ok, so don't bother locking */
-				if (iaxs[f->callno]) {
-					send_packet(f);
-					count++;
-				} 
-				if (f->retries < 0) {
-					/* This is not supposed to be retransmitted */
-					if (f->prev) 
-						f->prev->next = f->next;
-					else
-						iaxq.head = f->next;
-					if (f->next)
-						f->next->prev = f->prev;
-					else
-						iaxq.tail = f->prev;
-					iaxq.count--;
-					/* Free the iax frame */
-					freeme = f;
-				} else {
-					/* We need reliable delivery.  Schedule a retransmission */
-					f->retries++;
-					f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
-					signal_condition(&sched_lock, &sched_cond);
-				}
+		AST_LIST_TRAVERSE_SAFE_BEGIN(&iaxq.queue, f, list) {
+			if (f->sentyet)
+				continue;
+			
+			f->sentyet++;
+			/* Send a copy immediately -- errors here are ok, so don't bother locking */
+			if (iaxs[f->callno]) {
+				send_packet(f);
+				count++;
+			} 
+			if (f->retries < 0) {
+				/* This is not supposed to be retransmitted */
+				AST_LIST_REMOVE(&iaxq.queue, f, list);
+				iaxq.count--;
+				/* Free the iax frame */
+				iax_frame_free(f);
+			} else {
+				/* We need reliable delivery.  Schedule a retransmission */
+				f->retries++;
+				f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
+				signal_condition(&sched_lock, &sched_cond);
 			}
-			f = f->next;
-			if (freeme)
-				iax_frame_free(freeme);
-		}
-		ast_mutex_unlock(&iaxq.lock);
+		}
+		AST_LIST_TRAVERSE_SAFE_END
+		AST_LIST_UNLOCK(&iaxq.queue);
+
 		if (count >= 20)
 			ast_log(LOG_DEBUG, "chan_iax2: Sent %d queued outbound frames all at once\n", count);
 
@@ -9749,7 +9734,6 @@
 
 static int unload_module(void)
 {
-	ast_mutex_destroy(&iaxq.lock);
 	ast_mutex_destroy(&waresl.lock);
 	ast_custom_function_unregister(&iaxpeer_function);
 	return __unload_module();
@@ -9801,7 +9785,6 @@
 	}
 	ast_netsock_init(netsock);
 
-	ast_mutex_init(&iaxq.lock);
 	ast_mutex_init(&waresl.lock);
 	
 	ast_cli_register_multiple(iax2_cli, sizeof(iax2_cli) / sizeof(iax2_cli[0]));

Modified: team/russell/frame_caching/channels/chan_local.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/channels/chan_local.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/channels/chan_local.c (original)
+++ team/russell/frame_caching/channels/chan_local.c Thu Aug 24 19:19:16 2006
@@ -226,7 +226,7 @@
 	   frames on the owner channel (because they would be transferred to the
 	   outbound channel during the masquerade)
 	*/
-	if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && !p->owner->readq) {
+	if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && AST_LIST_EMPTY(&p->owner->readq)) {
 		/* Masquerade bridged channel into owner */
 		/* Lock everything we need, one by one, and give up if
 		   we can't get everything.  Remember, we'll get another
@@ -248,7 +248,7 @@
 	   when the local channels go away.
 	*/
 #if 0
-	} else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && !p->chan->readq) {
+	} else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && AST_LIST_EMPTY(&p->chan->readq)) {
 		/* Masquerade bridged channel into chan */
 		if (!ast_mutex_trylock(&(p->owner->_bridge)->lock)) {
 			if (!p->owner->_bridge->_softhangup) {

Modified: team/russell/frame_caching/channels/chan_zap.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/channels/chan_zap.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/channels/chan_zap.c (original)
+++ team/russell/frame_caching/channels/chan_zap.c Thu Aug 24 19:19:16 2006
@@ -3516,7 +3516,6 @@
 	pthread_t threadid;
 	pthread_attr_t attr;
 	struct ast_channel *chan;
-	struct ast_frame dtmf_frame = { .frametype = AST_FRAME_DTMF };
 
 	pthread_attr_init(&attr);
 	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
@@ -3558,10 +3557,8 @@
 			   and a DTMF_BEGIN event for channels that handle variable duration
 			   DTMF events
 			*/
-			p->subs[index].f.frametype = AST_FRAME_DTMF_BEGIN;
+			p->subs[index].f.frametype = AST_FRAME_DTMF;
 			p->subs[index].f.subclass = res & 0xff;
-			dtmf_frame.subclass = res & 0xff;
-			p->subs[index].f.next = ast_frdup(&dtmf_frame);
 #ifdef HAVE_PRI
 		}
 #endif

Modified: team/russell/frame_caching/channels/iax2-parser.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/channels/iax2-parser.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/channels/iax2-parser.c (original)
+++ team/russell/frame_caching/channels/iax2-parser.c Thu Aug 24 19:19:16 2006
@@ -40,6 +40,7 @@
 #include "asterisk/utils.h"
 #include "asterisk/unaligned.h"
 #include "asterisk/lock.h"
+#include "asterisk/threadstorage.h"
 
 #include "iax2.h"
 #include "iax2-parser.h"
@@ -48,6 +49,20 @@
 static int frames = 0;
 static int iframes = 0;
 static int oframes = 0;
+
+static unsigned int added_to_cache = 0;
+static unsigned int removed_from_cache = 0;
+static unsigned int frames_allocated = 0;
+static unsigned int frames_freed = 0;
+
+static void frame_cache_cleanup(void *data);
+
+/*! \brief A per-thread cache of iax_frame structures */
+AST_THREADSTORAGE_CUSTOM(frame_cache, frame_cache_init, frame_cache_cleanup);
+
+/*! \brief This is just so iax_frames, a list head struct for holding a list of
+ *  iax_frame structures, is defined. */
+AST_LIST_HEAD_NOLOCK(iax_frames, iax_frame);
 
 static void internaloutput(const char *str)
 {
@@ -926,22 +941,47 @@
 
 struct iax_frame *iax_frame_new(int direction, int datalen)
 {
+	struct iax_frames *iax_frames;
 	struct iax_frame *fr;
-	fr = malloc((int)sizeof(struct iax_frame) + datalen);
-	if (fr) {
-		fr->direction = direction;
-		fr->retrans = -1;
-		ast_atomic_fetchadd_int(&frames, 1);
-		if (fr->direction == DIRECTION_INGRESS)
-			ast_atomic_fetchadd_int(&iframes, 1);
-		else
-			ast_atomic_fetchadd_int(&oframes, 1);
-	}
+
+	/* Attempt to get a frame from this thread's cache */
+	if ((iax_frames = ast_threadstorage_get(&frame_cache, sizeof(*iax_frames)))) {
+		AST_LIST_TRAVERSE_SAFE_BEGIN(iax_frames, fr, list) {
+			if (fr->mallocd_datalen >= datalen) {
+				size_t mallocd_datalen = fr->mallocd_datalen;
+				AST_LIST_REMOVE_CURRENT(iax_frames, list);
+				memset(fr, 0, sizeof(*fr));
+				fr->mallocd_datalen = mallocd_datalen;
+				ast_atomic_fetchadd_int((int *) &removed_from_cache, 1);
+				break;
+			}
+		}
+		AST_LIST_TRAVERSE_SAFE_END
+	}
+
+	if (!fr) {
+		if (!(fr = ast_calloc(1, sizeof(*fr) + datalen)))
+			return NULL;
+		ast_atomic_fetchadd_int((int *) &frames_allocated, 1);
+		fr->mallocd_datalen = datalen;
+	}
+
+	fr->direction = direction;
+	fr->retrans = -1;
+	
+	ast_atomic_fetchadd_int(&frames, 1);
+	if (fr->direction == DIRECTION_INGRESS)
+		ast_atomic_fetchadd_int(&iframes, 1);
+	else
+		ast_atomic_fetchadd_int(&oframes, 1);
+	
 	return fr;
 }
 
-void iax_frame_free(struct iax_frame *fr)
-{
+static void __iax_frame_free(struct iax_frame *fr, int cache)
+{
+	struct iax_frames *iax_frames;
+
 	/* Note: does not remove from scheduler! */
 	if (fr->direction == DIRECTION_INGRESS)
 		ast_atomic_fetchadd_int(&iframes, -1);
@@ -952,10 +992,48 @@
 		return;
 	}
 	fr->direction = 0;
-	free(fr);
 	ast_atomic_fetchadd_int(&frames, -1);
+
+	if (!cache) {
+		free(fr);
+		ast_atomic_fetchadd_int((int *) &frames_freed, 1);
+		return;
+	}
+
+	if (!(iax_frames = ast_threadstorage_get(&frame_cache, sizeof(*iax_frames)))) {
+		free(fr);
+		ast_atomic_fetchadd_int((int *) &frames_freed, 1);
+		return;
+	}
+
+	AST_LIST_INSERT_HEAD(iax_frames, fr, list);
+	ast_atomic_fetchadd_int((int *) &added_to_cache, 1);
+}
+
+static void frame_cache_cleanup(void *data)
+{
+	struct iax_frames *frames = data;
+	struct iax_frame *cur;
+
+	while ((cur = AST_LIST_REMOVE_HEAD(frames, list))) {
+		__iax_frame_free(cur, 0);
+		ast_atomic_fetchadd_int((int *) &frames_freed, 1);
+	}
+
+	free(frames);
+}
+
+void iax_frame_free(struct iax_frame *fr)
+{
+	__iax_frame_free(fr, 1);
 }
 
 int iax_get_frames(void) { return frames; }
 int iax_get_iframes(void) { return iframes; }
 int iax_get_oframes(void) { return oframes; }
+
+unsigned int iax_get_added_to_cache(void) { return added_to_cache; }
+unsigned int iax_get_removed_from_cache(void) { return removed_from_cache; }
+unsigned int iax_get_frames_allocated(void) { return frames_allocated; }
+unsigned int iax_get_frames_freed(void) { return frames_freed; }
+

Modified: team/russell/frame_caching/channels/iax2-parser.h
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/channels/iax2-parser.h?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/channels/iax2-parser.h (original)
+++ team/russell/frame_caching/channels/iax2-parser.h Thu Aug 24 19:19:16 2006
@@ -17,6 +17,8 @@
  
 #ifndef _IAX2_PARSER_H
 #define _IAX2_PARSER_H
+
+#include "asterisk/linkedlists.h"
 
 struct iax_ies {
 	char *called_number;
@@ -115,10 +117,11 @@
 	/* Retransmission ID */
 	int retrans;
 	/* Easy linking */
-	struct iax_frame *next;
-	struct iax_frame *prev;
+	AST_LIST_ENTRY(iax_frame) list;
 	/* Actual, isolated frame header */
 	struct ast_frame af;
+	/*! Amount of space _allocated_ for data */
+	size_t mallocd_datalen;
 	unsigned char unused[AST_FRIENDLY_OFFSET];
 	unsigned char afdata[0];	/* Data for frame */
 };
@@ -149,6 +152,11 @@
 int iax_get_iframes(void);
 int iax_get_oframes(void);
 
+unsigned int iax_get_added_to_cache(void);
+unsigned int iax_get_removed_from_cache(void);
+unsigned int iax_get_frames_allocated(void);
+unsigned int iax_get_frames_freed(void);
+
 void iax_frame_wrap(struct iax_frame *fr, struct ast_frame *f);
 struct iax_frame *iax_frame_new(int direction, int datalen);
 void iax_frame_free(struct iax_frame *fr);

Modified: team/russell/frame_caching/include/asterisk/channel.h
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/include/asterisk/channel.h?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/include/asterisk/channel.h (original)
+++ team/russell/frame_caching/include/asterisk/channel.h Thu Aug 24 19:19:16 2006
@@ -410,7 +410,7 @@
 	unsigned int pickupgroup;			/*!< Pickup group - which calls groups can be picked up? */
 	unsigned int flags;				/*!< channel flags of AST_FLAG_ type */
 	unsigned short transfercapability;		/*!< ISDN Transfer Capbility - AST_FLAG_DIGITAL is not enough */
-	struct ast_frame *readq;
+	AST_LIST_HEAD_NOLOCK(, ast_frame) readq;
 	int alertpipe[2];
 
 	int nativeformats;				/*!< Kinds of data this channel can natively handle */

Modified: team/russell/frame_caching/include/asterisk/chanspy.h
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/include/asterisk/chanspy.h?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/include/asterisk/chanspy.h (original)
+++ team/russell/frame_caching/include/asterisk/chanspy.h Thu Aug 24 19:19:16 2006
@@ -49,7 +49,7 @@
 };
 
 struct ast_channel_spy_queue {
-	struct ast_frame *head;
+	AST_LIST_HEAD_NOLOCK(, ast_frame) list;
 	unsigned int samples;
 	unsigned int format;
 };

Modified: team/russell/frame_caching/include/asterisk/frame.h
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/include/asterisk/frame.h?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/include/asterisk/frame.h (original)
+++ team/russell/frame_caching/include/asterisk/frame.h Thu Aug 24 19:19:16 2006
@@ -32,6 +32,7 @@
 #include <sys/types.h>
 #include <sys/time.h>
 #include "asterisk/endian.h"
+#include "asterisk/linkedlists.h"
 
 struct ast_codec_pref {
 	char order[32];
@@ -97,6 +98,8 @@
 	int samples;				
 	/*! Was the data malloc'd?  i.e. should we free it when we discard the frame? */
 	int mallocd;				
+	/*! The number of bytes allocated for a malloc'd frame header */
+	size_t mallocd_hdr_len;
 	/*! How many bytes exist _before_ "data" that can be used if needed */
 	int offset;				
 	/*! Optional source of frame for debugging */
@@ -105,10 +108,8 @@
 	void *data;		
 	/*! Global delivery time */		
 	struct timeval delivery;
-	/*! Next/Prev for linking stand alone frames */
-	struct ast_frame *prev;			
-	/*! Next/Prev for linking stand alone frames */
-	struct ast_frame *next;			
+	/*! For placing in a linked list */
+	AST_LIST_ENTRY(ast_frame) frame_list;
 	/*! Timing data flag */
 	int has_timing_info;
 	/*! Timestamp in milliseconds */

Modified: team/russell/frame_caching/include/asterisk/slinfactory.h
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/include/asterisk/slinfactory.h?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/include/asterisk/slinfactory.h (original)
+++ team/russell/frame_caching/include/asterisk/slinfactory.h Thu Aug 24 19:19:16 2006
@@ -32,7 +32,7 @@
 #endif
 
 struct ast_slinfactory {
-	struct ast_frame *queue;
+	AST_LIST_HEAD_NOLOCK(, ast_frame) queue;
 	struct ast_trans_pvt *trans;
 	short hold[1280];
 	short *offset;

Modified: team/russell/frame_caching/main/abstract_jb.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/main/abstract_jb.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/main/abstract_jb.c (original)
+++ team/russell/frame_caching/main/abstract_jb.c Thu Aug 24 19:19:16 2006
@@ -324,10 +324,7 @@
 		return -1;
 	}
 
-	if (f->mallocd & AST_MALLOCD_HDR)
-		frr = ast_frdup(f);
-	else
-		frr = ast_frisolate(f);
+	frr = ast_frdup(f);
 
 	if (!frr) {
 		ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", chan->name);

Modified: team/russell/frame_caching/main/channel.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/main/channel.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/main/channel.c (original)
+++ team/russell/frame_caching/main/channel.c Thu Aug 24 19:19:16 2006
@@ -706,7 +706,7 @@
 int ast_queue_frame(struct ast_channel *chan, struct ast_frame *fin)
 {
 	struct ast_frame *f;
-	struct ast_frame *prev, *cur;
+	struct ast_frame *cur;
 	int blah = 1;
 	int qlen = 0;
 
@@ -716,17 +716,19 @@
 		return -1;
 	}
 	ast_channel_lock(chan);
-	prev = NULL;
-	for (cur = chan->readq; cur; cur = cur->next) {
-		if ((cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
-			/* Don't bother actually queueing anything after a hangup */
-			ast_frfree(f);
-			ast_channel_unlock(chan);
-			return 0;
-		}
-		prev = cur;
+
+	/* See if the last frame on the queue is a hangup, if so don't queue anything */
+	if ((cur = AST_LIST_LAST(&chan->readq)) && (cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) {
+		ast_frfree(f);
+		ast_channel_unlock(chan);
+		return 0;
+	}
+
+	/* Count how many frames exist on the queue */
+	AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) {
 		qlen++;
 	}
+
 	/* Allow up to 96 voice frames outstanding, and up to 128 total frames */
 	if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen  > 128)) {
 		if (fin->frametype != AST_FRAME_VOICE) {
@@ -739,10 +741,7 @@
 			return 0;
 		}
 	}
-	if (prev)
-		prev->next = f;
-	else
-		chan->readq = f;
+	AST_LIST_INSERT_TAIL(&chan->readq, f, frame_list);
 	if (chan->alertpipe[1] > -1) {
 		if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
 			ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
@@ -973,7 +972,7 @@
 {
 	int fd;
 	struct ast_var_t *vardata;
-	struct ast_frame *f, *fp;
+	struct ast_frame *f;
 	struct varshead *headp;
 	struct ast_datastore *datastore = NULL;
 	char name[AST_CHANNEL_NAME];
@@ -1024,13 +1023,8 @@
 		close(fd);
 	if ((fd = chan->timingfd) > -1)
 		close(fd);
-	f = chan->readq;
-	chan->readq = NULL;
-	while(f) {
-		fp = f;
-		f = f->next;
-		ast_frfree(fp);
-	}
+	while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
+		ast_frfree(f);
 	
 	/* Get rid of each of the data stores on the channel */
 	while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
@@ -1247,14 +1241,11 @@
 
 	spy->chan = NULL;
 
-	for (f = spy->read_queue.head; f; f = spy->read_queue.head) {
-		spy->read_queue.head = f->next;
+	while ((f = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list)))
 		ast_frfree(f);
-	}
-	for (f = spy->write_queue.head; f; f = spy->write_queue.head) {
-		spy->write_queue.head = f->next;
+	
+	while ((f = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list)))
 		ast_frfree(f);
-	}
 
 	if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
 		ast_cond_destroy(&spy->trigger);
@@ -1337,8 +1328,6 @@
 	trans = (dir == SPY_READ) ? &chan->spies->read_translator : &chan->spies->write_translator;
 
 	AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
-		struct ast_frame *last;
-		struct ast_frame *f1;	/* the frame to append */
 		struct ast_channel_spy_queue *queue;
 
 		ast_mutex_lock(&spy->lock);
@@ -1370,7 +1359,7 @@
 					break;
 				}
 			}
-			f1 = translated_frame;
+			AST_LIST_INSERT_TAIL(&queue->list, ast_frdup(f), frame_list);
 		} else {
 			if (f->subclass != queue->format) {
 				ast_log(LOG_WARNING, "Spy '%s' on channel '%s' wants format '%s', but frame is '%s', dropping\n",
@@ -1379,17 +1368,8 @@
 				ast_mutex_unlock(&spy->lock);
 				continue;
 			}
-			f1 = f;
-		}
-		/* duplicate and append f1 to the tail */
-		f1 = ast_frdup(f1);
-
-		for (last = queue->head; last && last->next; last = last->next)
-			;
-		if (last)
-			last->next = f1;
-		else
-			queue->head = f1;
+			AST_LIST_INSERT_TAIL(&queue->list, ast_frdup(f), frame_list);
+		}
 
 		queue->samples += f->samples;
 
@@ -1425,10 +1405,8 @@
 					ast_log(LOG_DEBUG, "Spy '%s' on channel '%s' %s queue too long, dropping frames\n",
 						spy->type, chan->name, (dir == SPY_READ) ? "read" : "write");
 				while (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
-					struct ast_frame *drop = queue->head;
-					
+					struct ast_frame *drop = AST_LIST_REMOVE_HEAD(&queue->list, frame_list);
 					queue->samples -= drop->samples;
-					queue->head = drop->next;
 					ast_frfree(drop);
 				}
 			}
@@ -1946,7 +1924,7 @@
 			blah = ZT_EVENT_TIMER_EXPIRED;
 
 		if (blah == ZT_EVENT_TIMER_PING) {
-			if (!chan->readq || !chan->readq->next) {
+			if (AST_LIST_EMPTY(&chan->readq) || !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) {
 				/* Acknowledge PONG unless we need it again */
 				if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
 					ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
@@ -1985,10 +1963,8 @@
 	}
 
 	/* Check for pending read queue */
-	if (chan->readq) {
-		f = chan->readq;
-		chan->readq = f->next;
-		f->next = NULL;
+	if (!AST_LIST_EMPTY(&chan->readq)) {
+		f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list);
 		/* Interpret hangup and return NULL */
 		/* XXX why not the same for frames from the channel ? */
 		if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
@@ -2014,11 +1990,13 @@
 
 	if (f) {
 		/* if the channel driver returned more than one frame, stuff the excess
-		   into the readq for the next ast_read call
+		   into the readq for the next ast_read call (note that we can safely assume
+		   that the readq is empty, because otherwise we would not have called into
+		   the channel driver and f would be only a single frame)
 		*/
-		if (f->next) {
-			chan->readq = f->next;
-			f->next = NULL;
+		if (AST_LIST_NEXT(f, frame_list)) {
+			AST_LIST_HEAD_SET_NOLOCK(&chan->readq, AST_LIST_NEXT(f, frame_list));
+			AST_LIST_NEXT(f, frame_list) = NULL;
 		}
 
 		switch (f->frametype) {
@@ -3068,7 +3046,7 @@
 	int x,i;
 	int res=0;
 	int origstate;
-	struct ast_frame *cur, *prev;
+	struct ast_frame *cur;
 	const struct ast_channel_tech *t;
 	void *t_pvt;
 	struct ast_callerid tmpcid;
@@ -3132,9 +3110,9 @@
 	clone->tech_pvt = t_pvt;
 
 	/* Swap the readq's */
-	cur = original->readq;
-	original->readq = clone->readq;
-	clone->readq = cur;
+	cur = AST_LIST_FIRST(&original->readq);
+	AST_LIST_HEAD_SET_NOLOCK(&original->readq, AST_LIST_FIRST(&clone->readq));
+	AST_LIST_HEAD_SET_NOLOCK(&clone->readq, cur);
 
 	/* Swap the alertpipes */
 	for (i = 0; i < 2; i++) {
@@ -3153,23 +3131,22 @@
 
 	/* Save any pending frames on both sides.  Start by counting
 	 * how many we're going to need... */
-	prev = NULL;
 	x = 0;
-	for (cur = clone->readq; cur; cur = cur->next) {
-		x++;
-		prev = cur;
-	}
-	/* If we had any, prepend them to the ones already in the queue, and
+	if (original->alertpipe[1] > -1) {
+		AST_LIST_TRAVERSE(&clone->readq, cur, frame_list)
+			x++;
+	}
+
+	/* If we had any, prepend them to the ones already in the queue, and 
 	 * load up the alertpipe */
-	if (prev) {
-		prev->next = original->readq;
-		original->readq = clone->readq;
-		clone->readq = NULL;
-		if (original->alertpipe[1] > -1) {
-			for (i = 0; i < x; i++)
-				write(original->alertpipe[1], &x, sizeof(x));
-		}
-	}
+	if (AST_LIST_FIRST(&clone->readq)) {
+		AST_LIST_INSERT_TAIL(&clone->readq, AST_LIST_FIRST(&original->readq), frame_list);
+		AST_LIST_HEAD_SET_NOLOCK(&original->readq, AST_LIST_FIRST(&clone->readq));
+		AST_LIST_HEAD_SET_NOLOCK(&clone->readq, NULL);
+		for (i = 0; i < x; i++)
+			write(original->alertpipe[1], &x, sizeof(x));
+	}
+	
 	clone->_softhangup = AST_SOFTHANGUP_DEV;
 
 
@@ -4086,9 +4063,7 @@
 	int bytestocopy;
 
 	while (samples) {
-		f = queue->head;
-
-		if (!f) {
+		if (!(f = AST_LIST_FIRST(&queue->list))) {
 			ast_log(LOG_ERROR, "Ran out of frames before buffer filled!\n");
 			break;
 		}
@@ -4103,10 +4078,9 @@
 		f->datalen -= bytestocopy;
 		f->offset += bytestocopy;
 		queue->samples -= tocopy;
-		if (!f->samples) {
-			queue->head = f->next;
-			ast_frfree(f);
-		}
+
+		if (!f->samples)
+			ast_frfree(AST_LIST_REMOVE_HEAD(&queue->list, frame_list));
 	}
 }
 
@@ -4136,19 +4110,19 @@
 	if (ast_test_flag(spy, CHANSPY_TRIGGER_FLUSH)) {
 		if (spy->read_queue.samples > spy->write_queue.samples) {
 			if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST)) {
-				for (result = spy->read_queue.head; result; result = result->next)
+				AST_LIST_TRAVERSE(&spy->read_queue.list, result, frame_list)
 					ast_frame_adjust_volume(result, spy->read_vol_adjustment);
 			}
-			result = spy->read_queue.head;
-			spy->read_queue.head = NULL;
+			result = AST_LIST_FIRST(&spy->read_queue.list);
+			AST_LIST_HEAD_SET_NOLOCK(&spy->read_queue.list, NULL);
 			spy->read_queue.samples = 0;
 		} else {
 			if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST)) {
-				for (result = spy->write_queue.head; result; result = result->next)
+				AST_LIST_TRAVERSE(&spy->write_queue.list, result, frame_list)
 					ast_frame_adjust_volume(result, spy->write_vol_adjustment);
 			}
-			result = spy->write_queue.head;
-			spy->write_queue.head = NULL;
+			result = AST_LIST_FIRST(&spy->write_queue.list);
+			AST_LIST_HEAD_SET_NOLOCK(&spy->write_queue.list, NULL);
 			spy->write_queue.samples = 0;
 		}
 		ast_clear_flag(spy, CHANSPY_TRIGGER_FLUSH);
@@ -4159,15 +4133,10 @@
 		return NULL;
 
 	/* short-circuit if both head frames have exactly what we want */
-	if ((spy->read_queue.head->samples == samples) &&
-	    (spy->write_queue.head->samples == samples)) {
-		read_frame = spy->read_queue.head;
-		spy->read_queue.head = read_frame->next;
-		read_frame->next = NULL;
-
-		write_frame = spy->write_queue.head;
-		spy->write_queue.head = write_frame->next;
-		write_frame->next = NULL;
+	if ((AST_LIST_FIRST(&spy->read_queue.list)->samples == samples) &&
+	    (AST_LIST_FIRST(&spy->write_queue.list)->samples == samples)) {
+		read_frame = AST_LIST_REMOVE_HEAD(&spy->read_queue.list, frame_list);
+		write_frame = AST_LIST_REMOVE_HEAD(&spy->write_queue.list, frame_list);
 
 		spy->read_queue.samples -= samples;
 		spy->write_queue.samples -= samples;
@@ -4200,10 +4169,10 @@
 	} else {
 		if (need_dup) {
 			result = ast_frdup(read_frame);
-			result->next = ast_frdup(write_frame);
+			AST_LIST_NEXT(result, frame_list) = ast_frdup(write_frame);
 		} else {
 			result = read_frame;
-			result->next = write_frame;
+			AST_LIST_NEXT(result, frame_list) = write_frame;
 		}
 	}
 

Modified: team/russell/frame_caching/main/frame.c
URL: http://svn.digium.com/view/asterisk/team/russell/frame_caching/main/frame.c?rev=41024&r1=41023&r2=41024&view=diff
==============================================================================
--- team/russell/frame_caching/main/frame.c (original)
+++ team/russell/frame_caching/main/frame.c Thu Aug 24 19:19:16 2006
@@ -41,12 +41,36 @@
 #include "asterisk/cli.h"
 #include "asterisk/term.h"
 #include "asterisk/utils.h"
+#include "asterisk/threadstorage.h"
+#include "asterisk/linkedlists.h"
 
 #ifdef TRACE_FRAMES
 static int headers = 0;
-static struct ast_frame *headerlist = NULL;
-AST_MUTEX_DEFINE_STATIC(framelock);
+static AST_LIST_HEAD_STATIC(headerlist, ast_frame);
 #endif
+
+static unsigned int mallocd_header_data_src = 0;
+static unsigned int mallocd_header_data = 0;
+static unsigned int mallocd_header_src = 0;
+static unsigned int mallocd_data_src = 0;
+static unsigned int mallocd_header = 0;
+static unsigned int mallocd_data = 0;
+static unsigned int mallocd_src = 0;
+static unsigned int mallocd_none = 0;
+
+static unsigned int added_to_cache = 0;
+static unsigned int removed_from_cache = 0;
+static unsigned int headers_allocated = 0;
+static unsigned int headers_freed = 0;
+
+static void frame_cache_cleanup(void *data);
+
+/*! \brief A per-thread cache of frame headers */
+AST_THREADSTORAGE_CUSTOM(frame_cache, frame_cache_init, frame_cache_cleanup);
+
+/*! \brief This is just so ast_frames, a list head struct for holding a list of
+ *  ast_frame structures, is defined. */
+AST_LIST_HEAD_NOLOCK(ast_frames, ast_frame);
 
 #define SMOOTHER_SIZE 8000
 
@@ -252,28 +276,92 @@
 
 static struct ast_frame *ast_frame_header_new(void)
 {
-	struct ast_frame *f = ast_calloc(1, sizeof(*f));
+	struct ast_frame *f;
+	struct ast_frames *frames;
+
+	if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
+		if ((f = AST_LIST_REMOVE_HEAD(frames, frame_list))) {
+			size_t mallocd_len = f->mallocd_hdr_len;
+			memset(f, 0, sizeof(*f));
+			f->mallocd_hdr_len = mallocd_len;
+			f->mallocd = AST_MALLOCD_HDR;
+			ast_atomic_fetchadd_int((int *) &removed_from_cache, 1);
+			return f;
+		}
+	}
+
+	if (!(f = ast_calloc(1, sizeof(*f))))
+		return NULL;
+
+	ast_atomic_fetchadd_int((int *) &headers_allocated, 1);
+
+	f->mallocd_hdr_len = sizeof(*f);
 #ifdef TRACE_FRAMES
-	if (f) {
-		f->prev = NULL;
-		ast_mutex_lock(&framelock);
-		headers++;
-		f->next = headerlist;
-		if (headerlist)
-			headerlist->prev = f;
-		headerlist = f;
-		ast_mutex_unlock(&framelock);
-	}
+	AST_LIST_LOCK(&headerlist);
+	headers++;
+	AST_LIST_INSERT_HEAD(&headerlist, f, frame_list);
+	AST_LIST_UNLOCK(&headerlist);
 #endif	
+	
 	return f;
 }
 
-/*!
- * \todo Important: I should be made more efficient.  Frame headers should
- * most definitely be cached
- */
+static void frame_cache_cleanup(void *data)
+{
+	struct ast_frames *frames = data;
+	struct ast_frame *f;
+
+	while ((f = AST_LIST_REMOVE_HEAD(frames, frame_list))) {
+		free(f);
+		ast_atomic_fetchadd_int((int *) &headers_freed, 1);
+	}
+	
+	free(frames);
+}
+
 void ast_frfree(struct ast_frame *fr)
 {
+	switch (fr->mallocd) {
+	case AST_MALLOCD_HDR | AST_MALLOCD_DATA | AST_MALLOCD_SRC:
+		ast_atomic_fetchadd_int((int *) &mallocd_header_data_src, 1);
+		break;
+	case AST_MALLOCD_HDR | AST_MALLOCD_DATA:
+		ast_atomic_fetchadd_int((int *) &mallocd_header_data, 1);
+		break;
+	case AST_MALLOCD_HDR | AST_MALLOCD_SRC:
+		ast_atomic_fetchadd_int((int *) &mallocd_header_src, 1);
+		break;
+	case AST_MALLOCD_DATA | AST_MALLOCD_SRC:
+		ast_atomic_fetchadd_int((int *) &mallocd_data_src, 1);
+		break;
+	case AST_MALLOCD_HDR:
+		ast_atomic_fetchadd_int((int *) &mallocd_header, 1);
+		break;
+	case AST_MALLOCD_DATA:
+		ast_atomic_fetchadd_int((int *) &mallocd_data, 1);
+		break;
+	case AST_MALLOCD_SRC:
+		ast_atomic_fetchadd_int((int *) &mallocd_src, 1);
+		break;
+	case 0:
+		ast_atomic_fetchadd_int((int *) &mallocd_none, 1);
+		break;
+	default:
+		ast_log(LOG_ERROR, "Totally bogus frame malloc'd value of '%d'!\n", fr->mallocd);
+	}
+
+	if (fr->mallocd == AST_MALLOCD_HDR) {
+		/* Cool, only the header is malloc'd, let's just cache those for now 
+		 * to keep things simple... */
+		struct ast_frames *frames;
+
+		if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
+			AST_LIST_INSERT_HEAD(frames, fr, frame_list);
+			ast_atomic_fetchadd_int((int *) &added_to_cache, 1);
+			return;
+		}
+	}
+
 	if (fr->mallocd & AST_MALLOCD_DATA) {
 		if (fr->data) 
 			free(fr->data - fr->offset);
@@ -284,17 +372,13 @@
 	}
 	if (fr->mallocd & AST_MALLOCD_HDR) {
 #ifdef TRACE_FRAMES
-		ast_mutex_lock(&framelock);
+		AST_LIST_LOCK(&headerlist);
 		headers--;
-		if (fr->next)
-			fr->next->prev = fr->prev;
-		if (fr->prev)

[... 296 lines stripped ...]


More information about the asterisk-commits mailing list