On 01/11/2011 06:27 PM, Amos Jeffries wrote:
> On 12/01/11 14:20, Alex Rousskov wrote:
>> On 01/11/2011 02:08 AM, Kinkie wrote:
>>> On Tue, Jan 11, 2011 at 8:03 AM, Amos Jeffries<[email protected]>
>>> wrote:
>>>> The profiler aufs assertions are caused by the profiler not being
>>>> thread
>>>> safe but attempting to account operations inside each of the AIO
>>>> threads.
>>>> Lack of thread safety is due to the stack the profiler maintains of
>>>> what
>>>> states are currently being counted.
>>>>
>>>> I don't believe we should be maintaining such a stack. Instead I
>>>> think we
>>>> should leverage the existing system stack by having the
>>>> PROF_start(X) macro
>>>> create a counter object in the local scope being counted. When the
>>>> local
>>>> scope exists for any reason the system stack object will be
>>>> destructed and
>>>> the destructor can accumulate the counters back into the global data.
>>>
>>> +1. I like this.
>>
>> I have a crude patch that implements such scope-based profiling. We used
>> it to find performance regressions in Squid3 (still an ongoing
>> project)...
>>
>> I would be happy to find that patch and post if somebody wants to
>> polish it.
>>
>> Thank you,
>>
>> Alex.
>
> Yes please. I threw together a patch last night. I'm happy compare and
> merge the two for inclusion.
Attached. It is crude and dirty, as promised. The code did work well for
me at some point though. Notes and caveats:
* Most of the stuff you need is in src/base/Profiling.{cc,h}. The rest
is mostly unimportant.
* ProfileProgress(Here) macro starts profiling from the current location
until the end of the async call or something like that. You can use many
of them. It was handy when you want to find the performance culprit in a
long function that does many things. Most or all of the
ProfileProgress(Here) calls added by the patch should be removed. They
were used for chasing problems.
* ProfileScope() macro is what this patch is using to implement
PROF_start(). I think we used either ProfileProgress(Here) or
ProfileScope(), but not both at the same time.
* Profiling scopes know when they are nested so that you can
report/exclude children time.
* The stats collection is not thread-safe because two threads may be in
one scope at the same time. If you want thread-safety, consider using
atomic integers.
* The patch includes several optimizations that you would have to
remove. I did not do that in fear of corrupting the patch. Not all of
those optimizations will result in visible performance improvement. They
need more work.
HTH,
Alex.
Profiling, debugging, and some optimization/fixes.
=== modified file 'include/MemPoolMalloc.h'
--- include/MemPoolMalloc.h 2010-05-29 00:59:35 +0000
+++ include/MemPoolMalloc.h 2010-10-23 04:04:00 +0000
@@ -21,6 +21,7 @@
*/
#include "MemPool.h"
+#include <list>
/// \ingroup MemPoolsAPI
class MemPoolMalloc : public MemImplementingAllocator
@@ -42,7 +43,7 @@
virtual void *allocate();
virtual void deallocate(void *, bool aggressive);
private:
- Stack<void *> freelist;
+ std::list<void *> freelist;
};
=== modified file 'include/profiling.h'
--- include/profiling.h 2010-07-07 15:48:48 +0000
+++ include/profiling.h 2010-10-25 02:15:23 +0000
@@ -216,8 +216,10 @@
#else /* USE_XPROF_STATS */
+#ifndef PROF_start
#define PROF_start(ARGS) ((void)0)
#define PROF_stop(ARGS) ((void)0)
+#endif
#endif /* USE_XPROF_STATS */
=== modified file 'lib/MemPool.cc'
--- lib/MemPool.cc 2010-05-30 09:13:54 +0000
+++ lib/MemPool.cc 2010-10-23 00:46:45 +0000
@@ -247,6 +247,7 @@
{
assert(obj != NULL);
(void) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(obj, obj_size);
+assert(MemPools::GetInstance().mem_idle_limit != 0);
deallocate(obj, MemPools::GetInstance().mem_idle_limit == 0);
++free_calls;
}
=== modified file 'lib/MemPoolMalloc.cc'
--- lib/MemPoolMalloc.cc 2010-05-30 00:15:16 +0000
+++ lib/MemPoolMalloc.cc 2010-10-23 01:05:56 +0000
@@ -54,8 +54,11 @@
void *
MemPoolMalloc::allocate()
{
- void *obj = freelist.pop();
- if (obj) {
+ void *obj = NULL;
+ if (!freelist.empty()) {
+ obj = freelist.back();
+ assert(obj);
+ freelist.pop_back();
memMeterDec(meter.idle);
saved_calls++;
} else {
@@ -127,13 +130,15 @@
bool
MemPoolMalloc::idleTrigger(int shift) const
{
- return freelist.count >> (shift ? 8 : 0);
+ return freelist.size() >> (shift ? 8 : 0);
}
void
MemPoolMalloc::clean(time_t maxage)
{
- while (void *obj = freelist.pop()) {
+ while (!freelist.empty()) {
+ void *obj = freelist.back();
+ freelist.pop_back();
memMeterDec(meter.idle);
memMeterDec(meter.alloc);
xfree(obj);
=== modified file 'src/Debug.h'
--- src/Debug.h 2010-05-26 03:06:02 +0000
+++ src/Debug.h 2010-10-25 02:12:31 +0000
@@ -143,4 +143,16 @@
/* Legacy debug function definitions */
SQUIDCEXTERN void _db_print(const char *,...) PRINTF_FORMAT_ARG1;
+
+/* Live call chain progress profiling */
+extern bool ForceLiveProfiling; ///< turns all live profilers on
+extern int LiveProfilingDepth; ///< number of profilers in the call chain
+extern timeval LiveProfilingStart; ///< the start time of the call chain
+extern void ProfileProgress(const char * const aStartName, const int aStartLine);
+extern void LiveProfilingReport();
+extern unsigned int LivePorfilingEventCount;
+#define Here __FILE__, __LINE__
+
+#include "base/Profiling.h"
+
#endif /* SQUID_DEBUG_H */
=== modified file 'src/EventLoop.cc'
--- src/EventLoop.cc 2010-05-26 03:06:02 +0000
+++ src/EventLoop.cc 2010-10-25 04:04:14 +0000
@@ -34,6 +34,7 @@
#include "EventLoop.h"
#include "base/AsyncCallQueue.h"
+#include "base/Profiling.h"
EventLoop::EventLoop() : errcount(0), last_loop(false), timeService(NULL),
primaryEngine(NULL)
@@ -42,13 +43,23 @@
void
EventLoop::checkEngine(AsyncEngine * engine, bool const primary)
{
+ static u_int64_t visits = 0;
+ ForceLiveProfiling = !(++visits % 50000);
+ getCurrentTime();
+ LiveProfilingStart = current_time;
+ LiveProfilingDepth = 0;
+ LivePorfilingEventCount = 0;
+
int requested_delay;
- if (!primary)
+ if (!primary) {
+ ProfileProgress(Here);
requested_delay = engine->checkEvents(0);
- else
+ } else
requested_delay = engine->checkEvents(loop_delay);
+ ProfileProgress(Here);
+
if (requested_delay < 0)
switch (requested_delay) {
@@ -71,6 +82,25 @@
if (requested_delay < loop_delay)
loop_delay = requested_delay;
}
+
+
+ getCurrentTime();
+ const int spent = tvSubUsec(LiveProfilingStart, current_time);
+ if (ForceLiveProfiling) {
+ debugs(1, 1, "timed checkEvents(" << primary << "): " << spent);
+ //LiveProfilingReport();
+ }
+
+ static double totalTime = 0;
+ static u_int64_t totalCount = 0;
+ totalTime += spent;
+ totalCount += LivePorfilingEventCount;
+ if (totalCount > 5000000) {
+ debugs(1, 1, "main loop events: " << totalTime << " / " << totalCount << " = " << totalTime/totalCount);
+ totalTime = 0;
+ totalCount = 0;
+ ScopeInfo::ReportAll();
+ }
}
void
=== modified file 'src/HttpHeader.cc'
--- src/HttpHeader.cc 2010-10-14 04:16:15 +0000
+++ src/HttpHeader.cc 2010-10-24 22:20:26 +0000
@@ -394,6 +394,7 @@
void
HttpHeader::clean()
{
+ ProfileProgress(Here);
HttpHeaderPos pos = HttpHeaderInitPos;
HttpHeaderEntry *e;
@@ -431,7 +432,9 @@
delete e;
}
}
+ ProfileProgress(Here);
entries.clean();
+ ProfileProgress(Here);
httpHeaderMaskInit(&mask, 0);
PROF_stop(HttpHeaderClean);
}
@@ -826,7 +829,7 @@
void
HttpHeader::compact()
{
- entries.prune(NULL);
+ entries.prune();
}
/*
@@ -1838,3 +1841,48 @@
refreshMask();
}
}
+
+
+
+HttpHeaderEntries::HttpHeaderEntries(): count(0)
+{
+}
+
+HttpHeaderEntries::~HttpHeaderEntries()
+{
+ assert(!count); // or we would leak entries
+ // TODO: we should own the entries and delete them when we are destructed
+}
+
+void
+HttpHeaderEntries::push_back(HttpHeaderEntry *e)
+{
+ assert(count < 1024); // XXX: hardcoded limit
+ items[count++] = e;
+}
+
+void
+HttpHeaderEntries::insert(HttpHeaderEntry *e)
+{
+ push_back(e); // XXX: old code inserted at position one (expensive!)
+}
+
+void
+HttpHeaderEntries::prune()
+{
+ size_t newCount = 0;
+ for (size_t i = 0; i < count; ++i) {
+ if (items[i]) {
+ if (newCount < i)
+ items[newCount] = items[i];
+ ++newCount;
+ }
+ }
+ count = newCount;
+}
+
+void
+HttpHeaderEntries::clean()
+{
+ count = 0;
+}
=== modified file 'src/HttpHeader.h'
--- src/HttpHeader.h 2010-08-25 00:14:25 +0000
+++ src/HttpHeader.h 2010-10-24 21:57:27 +0000
@@ -179,6 +179,22 @@
/// \todo CLEANUP: Kill this.
typedef struct _ETag ETag;
+class HttpHeaderEntry;
+
+class HttpHeaderEntries {
+public:
+ HttpHeaderEntries();
+ ~HttpHeaderEntries();
+
+ void push_back(HttpHeaderEntry *);
+ void insert(HttpHeaderEntry *);
+ void prune();
+ void clean();
+
+ size_t count;
+ HttpHeaderEntry *items[1024];
+};
+
class HttpHeaderEntry
{
@@ -257,7 +273,7 @@
inline bool chunked() const; ///< whether message uses chunked Transfer-Encoding
/* protected, do not use these, use interface functions instead */
- Vector<HttpHeaderEntry *> entries; /**< parsed fields in raw format */
+ HttpHeaderEntries entries; /**< parsed fields in raw format */
HttpHeaderMask mask; /**< bit set <=> entry present */
http_hdr_owner_type owner; /**< request or reply */
int len; /**< length when packed, not counting terminating null-byte */
=== modified file 'src/MemObject.cc'
--- src/MemObject.cc 2009-08-04 02:31:27 +0000
+++ src/MemObject.cc 2010-10-24 16:33:01 +0000
@@ -137,6 +137,7 @@
void
MemObject::write ( StoreIOBuffer writeBuffer, STMCB *callback, void *callbackData)
{
+ ProfileProgress(Here);
PROF_start(MemObject_write);
debugs(19, 6, "memWrite: offset " << writeBuffer.offset << " len " << writeBuffer.length);
@@ -149,7 +150,9 @@
assert (data_hdr.endOffset() || writeBuffer.offset == 0);
assert (data_hdr.write (writeBuffer));
+ ProfileProgress(Here);
callback (callbackData, writeBuffer);
+ ProfileProgress(Here);
PROF_stop(MemObject_write);
}
=== modified file 'src/Server.cc'
--- src/Server.cc 2010-09-13 02:25:09 +0000
+++ src/Server.cc 2010-10-24 20:57:26 +0000
@@ -60,6 +60,7 @@
#endif
receivedWholeRequestBody(false)
{
+ ProfileProgress(Here);
fwd = theFwdState;
entry = fwd->entry;
=== modified file 'src/base/AsyncCall.cc'
--- src/base/AsyncCall.cc 2009-04-09 22:31:13 +0000
+++ src/base/AsyncCall.cc 2010-10-24 01:52:02 +0000
@@ -28,10 +28,14 @@
void
AsyncCall::make()
{
+ ProfileProgress(Here);
+
debugs(debugSection, debugLevel, HERE << "make call " << name <<
" [call"<< id << ']');
if (canFire()) {
+ ProfileProgress(Here);
fire();
+ ProfileProgress(Here);
return;
}
=== modified file 'src/base/AsyncCallQueue.cc'
--- src/base/AsyncCallQueue.cc 2009-04-09 22:31:13 +0000
+++ src/base/AsyncCallQueue.cc 2010-10-25 01:25:12 +0000
@@ -8,11 +8,12 @@
#include "base/AsyncCallQueue.h"
#include "base/AsyncCall.h"
+#include "SquidTime.h"
AsyncCallQueue *AsyncCallQueue::TheInstance = 0;
-AsyncCallQueue::AsyncCallQueue(): theHead(NULL), theTail(NULL)
+AsyncCallQueue::AsyncCallQueue(): theHead(NULL), theTail(NULL), count(0)
{
}
@@ -27,6 +28,7 @@
} else { // create queue from cratch
theHead = theTail = call;
}
+ ++count;
}
// Fire all scheduled calls; returns true if at least one call was fired.
@@ -48,10 +50,42 @@
call->theNext = NULL;
if (theTail == call)
theTail = NULL;
+ --count;
+
+ static u_int64_t visits = 0;
+ ForceLiveProfiling = !(++visits % 50000);
+ getCurrentTime();
+ LiveProfilingStart = current_time;
+ LiveProfilingDepth = 0;
+ LivePorfilingEventCount = 0;
debugs(call->debugSection, call->debugLevel, "entering " << *call);
+ ProfileProgress(Here);
call->make();
+ ProfileProgress(Here);
debugs(call->debugSection, call->debugLevel, "leaving " << *call);
+
+ getCurrentTime();
+ const int spent = tvSubUsec(LiveProfilingStart, current_time);
+ static double sum = 0;
+ sum += spent;
+ if (spent >= 500 || LiveProfilingDepth >= 100 || ForceLiveProfiling) {
+ debugs(call->debugSection, 1, "timed " << call->name << ": " << spent << ' ' << sum/visits << " depth: " << count);
+ LiveProfilingReport();
+ }
+
+ static double totalTime = 0;
+ static double totalCount = 0;
+ totalTime += spent;
+ totalCount += LivePorfilingEventCount;
+ if (totalCount > 10000000.0) {
+ debugs(1, 1, "async call events: " << totalTime << " / " << totalCount << " = " << totalTime/totalCount);
+ totalTime = 0;
+ totalCount = 0;
+ }
+
+ ForceLiveProfiling = false;
+ LiveProfilingDepth = 0;
}
AsyncCallQueue &
=== modified file 'src/base/AsyncCallQueue.h'
--- src/base/AsyncCallQueue.h 2009-04-09 22:31:13 +0000
+++ src/base/AsyncCallQueue.h 2010-10-23 22:39:36 +0000
@@ -33,6 +33,7 @@
AsyncCall::Pointer theHead;
AsyncCall::Pointer theTail;
+ int count;
static AsyncCallQueue *TheInstance;
};
=== added file 'src/base/Profiling.cc'
--- src/base/Profiling.cc 1970-01-01 00:00:00 +0000
+++ src/base/Profiling.cc 2010-10-25 04:06:24 +0000
@@ -0,0 +1,74 @@
+#include "base/Profiling.h"
+#include "Debug.h"
+#include <set>
+#include <algorithm>
+
+u_int64_t ScopeInfo::LastId = 0;
+
+static std::set<ScopeInfo*> Scopes;
+
+static u_int64_t MinReportVolume = 0;
+
+
+ScopeInfo::ScopeInfo(const char * const aName, const int aLine):
+ totalTicks(0), totalVisits(0),
+ fileName(aName), fileLine(aLine), id(++LastId)
+{
+ doRegister();
+}
+
+ScopeInfo::~ScopeInfo()
+{
+ unRegister();
+}
+
+void
+ScopeInfo::doRegister()
+{
+ Scopes.insert(this);
+}
+
+void
+ScopeInfo::unRegister()
+{
+ Scopes.erase(this);
+}
+
+void
+ScopeInfo::report()
+{
+ if (MinReportVolume && totalVisits >= MinReportVolume) {
+ debugs(1,1, fileName << ':' << fileLine << ": scope" << id << ": " <<
+ totalTicks << " / " << totalVisits << " = " <<
+ (static_cast<double>(totalTicks)/(totalVisits ? totalVisits : 1)));
+ totalVisits = 0;
+ totalTicks = 0;
+ }
+}
+
+static double TotalVisits = 0;
+static double TotalTicks = 0;
+
+static
+void ReportOne(ScopeInfo *scope)
+{
+ TotalTicks += scope->totalTicks;
+ TotalVisits += scope->totalVisits;
+ scope->report();
+}
+
+void
+ScopeInfo::ReportAll()
+{
+ TotalTicks = 0;
+ TotalVisits = 0;
+
+ debugs(1,1, "Total profiling scopes: " << Scopes.size());
+ MinReportVolume = 1;
+ std::for_each(Scopes.begin(), Scopes.end(), &ReportOne);
+ MinReportVolume = INT_MAX;
+
+ debugs(1,1, "All scopes: " <<
+ TotalTicks << " / " << TotalVisits << " = " <<
+ (static_cast<double>(TotalTicks)/(TotalVisits ? TotalVisits : 1)));
+}
=== added file 'src/base/Profiling.h'
--- src/base/Profiling.h 1970-01-01 00:00:00 +0000
+++ src/base/Profiling.h 2010-10-25 02:25:35 +0000
@@ -0,0 +1,112 @@
+#ifndef SQUID_BASE_PROFILING_H
+#define SQUID_BASE_PROFILING_H
+
+#include "config.h"
+
+/* start future ticking.h; XXX: move */
+
+#if !_SQUID_SOLARIS_
+typedef int64_t hrtime_t;
+#endif
+
+#if defined(__GNUC__) && ( defined(__i386) || defined(__i386__) )
+static inline hrtime_t
+get_tick(void)
+{
+ hrtime_t regs;
+
+asm volatile ("rdtsc":"=A" (regs));
+ return regs;
+ /* We need return value, we rely on CC to optimise out needless subf calls */
+ /* Note that "rdtsc" is relatively slow OP and stalls the CPU pipes, so use it wisely */
+}
+
+#elif defined(__GNUC__) && ( defined(__x86_64) || defined(__x86_64__) )
+static inline hrtime_t
+get_tick(void)
+{
+ uint32_t lo, hi;
+ // Based on an example in Wikipedia
+ /* We cannot use "=A", since this would use %rax on x86_64 */
+asm volatile ("rdtsc" : "=a" (lo), "=d" (hi));
+ return (hrtime_t)hi << 32 | lo;
+}
+
+#elif defined(__GNUC__) && defined(__alpha)
+static inline hrtime_t
+get_tick(void)
+{
+ hrtime_t regs;
+
+asm volatile ("rpcc %0" : "=r" (regs));
+ return regs;
+}
+
+#elif defined(_M_IX86) && defined(_MSC_VER) /* x86 platform on Microsoft C Compiler ONLY */
+static __inline hrtime_t
+get_tick(void)
+{
+ hrtime_t regs;
+
+ __asm {
+ cpuid
+ rdtsc
+ mov eax,DWORD PTR regs[0]
+ mov edx,DWORD PTR regs[4]
+ }
+ return regs;
+}
+
+#else
+/* This CPU is unsupported. Short-circuit, no profiling here */
+#define get_tick() 0
+#undef USE_XPROF_STATS
+#define USE_XPROF_STATS 0
+#endif
+
+/* end future ticking.h */
+
+class ScopeInfo {
+public:
+ static void ReportAll();
+
+ ScopeInfo(const char * const aName, const int aLine);
+ ~ScopeInfo();
+
+ void doRegister();
+ void unRegister();
+ void report();
+
+ u_int64_t totalTicks;
+ u_int64_t totalVisits;
+
+ const char * const fileName;
+ const int fileLine;
+
+ const u_int64_t id;
+ static u_int64_t LastId;
+};
+
+class ScopeProfiler {
+public:
+ ScopeProfiler(ScopeInfo &aScope): scope(aScope), startTicks(get_tick()) {}
+ ~ScopeProfiler() {
+ scope.totalTicks += get_tick() - startTicks;
+ if (++scope.totalVisits > 100000)
+ scope.report();
+ }
+
+ ScopeInfo &scope;
+ u_int64_t startTicks;
+};
+
+#define ProfileScope(name, line, uid) \
+ static ScopeInfo ScopeInfoName ## uid(name, line); \
+ ScopeProfiler profiler ## uid(ScopeInfoName ## uid);
+
+#undef PROF_start
+#undef PROF_stop
+#define PROF_start(type) ProfileScope(__FILE__, __LINE__, type)
+#define PROF_stop(type)
+
+#endif /* SQUID_BASE_PROFILING_H */
=== modified file 'src/client_side.cc'
--- src/client_side.cc 2010-09-22 23:04:40 +0000
+++ src/client_side.cc 2010-10-24 17:16:05 +0000
@@ -2040,6 +2040,8 @@
StoreIOBuffer tempBuffer;
int r;
+ ProfileProgress(Here);
+
/* pre-set these values to make aborting simpler */
*method_p = METHOD_NONE;
@@ -2136,7 +2138,9 @@
HttpParserReqSz(hp));
/* Ok, all headers are received */
+ ProfileProgress(Here);
http = new ClientHttpRequest(conn);
+ ProfileProgress(Here);
http->req_sz = HttpParserRequestLen(hp);
result = ClientSocketContextNew(http);
@@ -2168,6 +2172,7 @@
*t = '\0';
#endif
+ ProfileProgress(Here);
/* Rewrite the URL in transparent or accelerator mode */
/* NP: there are several cases to traverse here:
@@ -2209,10 +2214,12 @@
strcpy(http->uri, url);
}
+ ProfileProgress(Here);
setLogUri(http, http->uri);
debugs(33, 5, "parseHttpRequest: Complete request received");
result->flags.parsed_ok = 1;
xfree(url);
+ ProfileProgress(Here);
return result;
}
@@ -2357,6 +2364,7 @@
static void
clientProcessRequest(ConnStateData *conn, HttpParser *hp, ClientSocketContext *context, const HttpRequestMethod& method, HttpVersion http_ver)
{
+ ProfileProgress(Here);
ClientHttpRequest *http = context->http;
HttpRequest *request = NULL;
bool notedUseOfBuffer = false;
@@ -2434,6 +2442,8 @@
goto finish;
}
+ ProfileProgress(Here);
+
request->flags.accelerated = http->flags.accel;
request->flags.ignore_cc = conn->port->ignore_cc;
request->flags.no_direct = request->flags.accelerated ? !conn->port->allow_direct : 0;
@@ -2478,6 +2488,8 @@
request->my_addr = conn->me;
request->http_ver = http_ver;
+ ProfileProgress(Here);
+
if (request->header.chunked()) {
chunked = true;
} else if (request->header.has(HDR_TRANSFER_ENCODING)) {
@@ -2538,6 +2550,8 @@
if (http->request->method == METHOD_CONNECT)
context->mayUseConnection(true);
+ ProfileProgress(Here);
+
/* Do we expect a request-body? */
expectBody = chunked || request->content_length > 0;
if (!context->mayUseConnection() && expectBody) {
@@ -2573,11 +2587,13 @@
context->mayUseConnection(!request->body_pipe->productionEnded());
}
+ ProfileProgress(Here);
http->calloutContext = new ClientRequestContext(http);
http->doCallouts();
finish:
+ ProfileProgress(Here);
if (!notedUseOfBuffer)
connNoteUseOfBuffer(conn, http->req_sz);
@@ -2594,6 +2610,7 @@
comm_reset_close(conn->fd);
return;
}
+ ProfileProgress(Here);
}
static void
@@ -2636,6 +2653,7 @@
HttpVersion http_ver;
HttpParser hp;
+ ProfileProgress(Here);
debugs(33, 5, "clientParseRequest: FD " << conn->fd << ": attempting to parse");
// Loop while we have read bytes that are not needed for producing the body
@@ -2666,7 +2684,7 @@
PROF_start(parseHttpRequest);
context = parseHttpRequest(conn, &hp, &method, &http_ver);
-
+ ProfileProgress(Here);
PROF_stop(parseHttpRequest);
/* partial or incomplete request */
@@ -2683,7 +2701,9 @@
commSetTimeout(conn->fd, Config.Timeout.lifetime, clientLifetimeTimeout,
context->http);
+ ProfileProgress(Here);
clientProcessRequest(conn, &hp, context, method, http_ver);
+ ProfileProgress(Here);
parsed_req = true;
@@ -2697,12 +2717,16 @@
/* XXX where to 'finish' the parsing pass? */
+ ProfileProgress(Here);
+
return parsed_req;
}
void
ConnStateData::clientReadRequest(const CommIoCbParams &io)
{
+ ProfileProgress(Here);
+
debugs(33,5,HERE << "clientReadRequest FD " << io.fd << " size " << io.size);
Must(reading());
reader = NULL;
@@ -2778,9 +2802,11 @@
* be if we have an incomplete request.
* XXX: This duplicates ClientSocketContext::keepaliveNextRequest
*/
+ ProfileProgress(Here);
if (getConcurrentRequestCount() == 0 && commIsHalfClosed(fd)) {
debugs(33, 5, "clientReadRequest: FD " << fd << ": half-closed connection, no completed request parsed, connection closing.");
comm_close(fd);
+ ProfileProgress(Here);
return;
}
}
@@ -2788,7 +2814,9 @@
if (!isOpen())
return;
+ ProfileProgress(Here);
clientAfterReadingRequests(do_next_read);
+ ProfileProgress(Here);
}
/**
@@ -2800,6 +2828,7 @@
bool
ConnStateData::handleReadData(char *buf, size_t size)
{
+ ProfileProgress(Here);
char *current_buf = in.addressToReadInto();
if (buf != current_buf)
@@ -2809,9 +2838,12 @@
in.buf[in.notYetUsed] = '\0'; /* Terminate the string */
+ ProfileProgress(Here);
+
// if we are reading a body, stuff data into the body pipe
if (bodyPipe != NULL)
return handleRequestBodyData();
+ ProfileProgress(Here);
return true;
}
@@ -2825,6 +2857,7 @@
bool
ConnStateData::handleRequestBodyData()
{
+ ProfileProgress(Here);
assert(bodyPipe != NULL);
size_t putSize = 0;
@@ -2846,6 +2879,7 @@
if (putSize > 0)
connNoteUseOfBuffer(this, putSize);
+ ProfileProgress(Here);
if (!bodyPipe) {
debugs(33,5, HERE << "produced entire request body for FD " << fd);
@@ -2853,11 +2887,14 @@
/* we've finished reading like good clients,
* now do the close that initiateClose initiated.
*/
+ ProfileProgress(Here);
comm_close(fd);
+ ProfileProgress(Here);
return false;
}
}
+ ProfileProgress(Here);
return true;
}
=== modified file 'src/client_side_reply.cc'
--- src/client_side_reply.cc 2010-09-28 17:43:42 +0000
+++ src/client_side_reply.cc 2010-10-24 20:39:21 +0000
@@ -616,6 +616,7 @@
void
clientReplyContext::processMiss()
{
+ ProfileProgress(Here);
char *url = http->uri;
HttpRequest *r = http->request;
ErrorState *err = NULL;
@@ -768,6 +769,7 @@
void
clientReplyContext::created(StoreEntry *newEntry)
{
+ ProfileProgress(Here);
if (lookingforstore == 1)
purgeFoundGet(newEntry);
else if (lookingforstore == 2)
@@ -1488,6 +1490,7 @@
void
clientReplyContext::identifyFoundObject(StoreEntry *newEntry)
{
+ ProfileProgress(Here);
StoreEntry *e = newEntry;
HttpRequest *r = http->request;
@@ -1541,6 +1544,7 @@
#endif
+ ProfileProgress(Here);
if (NULL == http->storeEntry()) {
/** \li If no StoreEntry object is current assume this object isn't in the cache set MISS*/
debugs(85, 3, "clientProcessRequest2: StoreEntry is NULL - MISS");
@@ -1607,6 +1611,7 @@
void
clientGetMoreData(clientStreamNode * aNode, ClientHttpRequest * http)
{
+ ProfileProgress(Here);
/* Test preconditions */
assert(aNode != NULL);
assert(cbdataReferenceValid(aNode));
@@ -1629,8 +1634,10 @@
tempBuffer.length = next->readBuffer.length;
tempBuffer.data = next->readBuffer.data;
+ ProfileProgress(Here);
storeClientCopy(context->sc, http->storeEntry(),
tempBuffer, clientReplyContext::SendMoreData, context);
+ ProfileProgress(Here);
return;
}
@@ -1639,6 +1646,7 @@
return;
}
+ ProfileProgress(Here);
// OPTIONS with Max-Forwards:0 handled in clientProcessRequest()
if (context->http->request->method == METHOD_TRACE) {
@@ -1651,13 +1659,17 @@
http->logType = LOG_TCP_MISS;
context->doGetMoreData();
- } else
+ } else {
+ ProfileProgress(Here);
context->identifyStoreObject();
+ }
+ ProfileProgress(Here);
}
void
clientReplyContext::doGetMoreData()
{
+ ProfileProgress(Here);
/* We still have to do store logic processing - vary, cache hit etc */
if (http->storeEntry() != NULL) {
/* someone found the object in the cache for us */
@@ -1702,6 +1714,7 @@
/* MISS CASE, http->logType is already set! */
processMiss();
}
+ ProfileProgress(Here);
}
/** The next node has removed itself from the stream. */
=== modified file 'src/client_side_request.cc'
--- src/client_side_request.cc 2010-09-28 17:43:42 +0000
+++ src/client_side_request.cc 2010-10-24 17:27:51 +0000
@@ -1135,6 +1135,7 @@
void
ClientHttpRequest::httpStart()
{
+ ProfileProgress(Here);
PROF_start(httpStart);
logType = LOG_TAG_NONE;
debugs(85, 4, "ClientHttpRequest::httpStart: " << log_tags[logType] << " for '" << uri << "'");
@@ -1277,6 +1278,7 @@
void
ClientHttpRequest::doCallouts()
{
+ ProfileProgress(Here);
assert(calloutContext);
/*Save the original request for logging purposes*/
@@ -1287,6 +1289,7 @@
debugs(83, 3, HERE << "Doing calloutContext->clientAccessCheck()");
calloutContext->http_access_done = true;
calloutContext->clientAccessCheck();
+ ProfileProgress(Here);
return;
}
@@ -1296,7 +1299,10 @@
if (Adaptation::AccessCheck::Start(
Adaptation::methodReqmod, Adaptation::pointPreCache,
request, NULL, adaptationAclCheckDoneWrapper, calloutContext))
+{
+ ProfileProgress(Here);
return; // will call callback
+}
}
#endif
@@ -1308,6 +1314,7 @@
debugs(83, 3, HERE << "Doing calloutContext->clientRedirectStart()");
calloutContext->redirect_state = REDIRECT_PENDING;
calloutContext->clientRedirectStart();
+ ProfileProgress(Here);
return;
}
}
@@ -1316,6 +1323,7 @@
debugs(83, 3, HERE << "Doing calloutContext->clientAccessCheck2()");
calloutContext->adapted_http_access_done = true;
calloutContext->clientAccessCheck2();
+ ProfileProgress(Here);
return;
}
@@ -1323,6 +1331,7 @@
debugs(83, 3, HERE << "Doing clientInterpretRequestHeaders()");
calloutContext->interpreted_req_hdrs = 1;
clientInterpretRequestHeaders(this);
+ ProfileProgress(Here);
}
if (!calloutContext->no_cache_done) {
@@ -1331,6 +1340,7 @@
if (Config.accessList.noCache && request->flags.cachable) {
debugs(83, 3, HERE << "Doing calloutContext->checkNoCache()");
calloutContext->checkNoCache();
+ ProfileProgress(Here);
return;
}
}
@@ -1344,9 +1354,11 @@
int tos = aclMapTOS(Config.accessList.clientside_tos, &ch);
if (tos)
comm_set_tos(getConn()->fd, tos);
+ ProfileProgress(Here);
}
}
+ ProfileProgress(Here);
cbdataReferenceDone(calloutContext->http);
delete calloutContext;
calloutContext = NULL;
@@ -1356,13 +1368,16 @@
#endif
debugs(83, 3, HERE << "calling processRequest()");
+ ProfileProgress(Here);
processRequest();
+ ProfileProgress(Here);
#if ICAP_CLIENT
Adaptation::Icap::History::Pointer ih = request->icapHistory();
if (ih != NULL)
ih->logType = logType;
#endif
+ ProfileProgress(Here);
}
#if !_USE_INLINE_
=== modified file 'src/comm_epoll.cc'
--- src/comm_epoll.cc 2010-10-14 04:16:15 +0000
+++ src/comm_epoll.cc 2010-10-24 22:56:01 +0000
@@ -280,6 +280,7 @@
PROF_stop(comm_check_incoming);
getCurrentTime();
+ LiveProfilingStart = current_time;
statHistCount(&statCounter.select_fds_hist, num);
@@ -287,6 +288,7 @@
return COMM_TIMEOUT; /* No error.. */
PROF_start(comm_handle_ready_fd);
+ ProfileProgress(Here);
for (i = 0, cevents = pevents; i < num; i++, cevents++) {
fd = cevents->data.fd;
@@ -297,6 +299,8 @@
// TODO: add EPOLLPRI??
+ ProfileProgress(Here);
+
if (cevents->events & (EPOLLIN|EPOLLHUP|EPOLLERR) || F->flags.read_pending) {
if ((hdl = F->read_handler) != NULL) {
debugs(5, DEBUG_EPOLL ? 0 : 8, "comm_select(): Calling read handler on FD " << fd);
@@ -313,6 +317,8 @@
}
}
+ ProfileProgress(Here);
+
if (cevents->events & (EPOLLOUT|EPOLLHUP|EPOLLERR)) {
if ((hdl = F->write_handler) != NULL) {
debugs(5, DEBUG_EPOLL ? 0 : 8, "comm_select(): Calling write handler on FD " << fd);
@@ -329,6 +335,7 @@
}
}
+ ProfileProgress(Here);
PROF_stop(comm_handle_ready_fd);
return COMM_OK;
=== modified file 'src/debug.cc'
--- src/debug.cc 2010-07-06 23:09:44 +0000
+++ src/debug.cc 2010-10-25 02:12:46 +0000
@@ -805,3 +805,85 @@
return path+BuildPrefixLength;
}
+
+bool ForceLiveProfiling = false;
+int LiveProfilingDepth = 0;
+timeval LiveProfilingStart = {0, 0};
+static const int LiveProfilingDepthMax = 10240;
+unsigned int LivePorfilingEventCount = 0;
+
+class LiveProfilingHistoryStep {
+public:
+ const char *fileName;
+ int lineNo;
+ timeval stamp;
+};
+static LiveProfilingHistoryStep LiveProfilingHistory[LiveProfilingDepthMax];
+void ProfileProgress(const char * const fileName, const int lineNo)
+{
+ ++LivePorfilingEventCount;
+return;
+ getCurrentTime();
+
+ LiveProfilingHistoryStep &step =
+ LiveProfilingHistory[min(LiveProfilingDepth++, LiveProfilingDepthMax)];
+ step.fileName = fileName;
+ step.lineNo = lineNo;
+ step.stamp = current_time;
+}
+
+void LiveProfilingReport()
+{
+ timeval last = LiveProfilingStart;
+ int aggr = 0;
+ for (int i = 0; i < LiveProfilingDepth; ++i) {
+ LiveProfilingHistoryStep &step = LiveProfilingHistory[i];
+ const int spent = tvSubUsec(last, step.stamp);
+ aggr += spent;
+ debugs(1,1, step.fileName << ':' << step.lineNo << ": step" << i <<
+ ": " << spent << " / " << aggr);
+ last = step.stamp;
+ }
+}
+
+#if 0 /* XXX: remove old */
+void ProfileProgress(const char * const fileName, const int lineNo)
+{
+ static const char *LastFileName = "?";
+ static int LastLineNo = 0;
+ static int LastSpent = 0;
+
+ getCurrentTime();
+ static timeval Last = { 0,0 };
+ static int Aggr = 0;
+ if (!LiveProfilingDepth++) {
+ Last = LiveProfilingStart;
+ Aggr = 0;
+ LastFileName = 0;
+ LastLineNo = LastSpent = 0;
+ }
+ const int spent = tvSubUsec(Last, current_time);
+ Aggr += spent;
+ Last = current_time;
+
+ if (!ForceLiveProfiling && spent > 200 && LastFileName) {
+ debugs(1,1, LastFileName << ':' << LastLineNo << ": " <<
+ (LiveProfilingDepth-1) << "-spent: " << LastSpent << " (old)");
+ LastFileName = 0;
+ }
+
+ if (ForceLiveProfiling || spent > 200) {
+ debugs(1,1, fileName << ':' << lineNo << ": " << LiveProfilingDepth <<
+ "-spent: " << spent << " / " << Aggr << " or "
+ << tvSubUsec(LiveProfilingStart, current_time));
+ LastFileName = 0;
+ } else {
+ LastFileName = fileName;
+ LastLineNo = lineNo;
+ LastSpent = spent;
+ }
+}
+#endif
+
+
+#include "base/Profiling.cc"
=== modified file 'src/forward.cc'
--- src/forward.cc 2010-10-14 04:16:15 +0000
+++ src/forward.cc 2010-10-24 20:56:11 +0000
@@ -105,6 +105,7 @@
// Called once, right after object creation, when it is safe to set self
void FwdState::start(Pointer aSelf)
{
+ ProfileProgress(Here);
// Protect ourselves from being destroyed when the only Server pointing
// to us is gone (while we expect to talk to more Servers later).
// Once we set self, we are responsible for clearing it when we do not
@@ -116,6 +117,7 @@
entry->registerAbort(FwdState::abort, this);
peerSelect(request, entry, fwdStartCompleteWrapper, this);
+ ProfileProgress(Here);
// TODO: set self _after_ the peer is selected because we do not need
// self until we start talking to some Server.
@@ -199,6 +201,7 @@
void
FwdState::fwdStart(int client_fd, StoreEntry *entry, HttpRequest *request)
{
+ ProfileProgress(Here);
/** \note
* client_addr == no_addr indicates this is an "internal" request
* from peer_digest.c, asn.c, netdb.c, etc and should always
@@ -789,6 +792,7 @@
void
FwdState::connectStart()
{
+ ProfileProgress(Here);
const char *url = entry->url();
int fd = -1;
FwdServer *fs = servers;
@@ -960,6 +964,7 @@
updateHierarchyInfo();
commConnectStart(fd, host, port, fwdConnectDoneWrapper, this);
+ ProfileProgress(Here);
}
void
@@ -988,6 +993,7 @@
void
FwdState::dispatch()
{
+ ProfileProgress(Here);
peer *p = NULL;
debugs(17, 3, "fwdDispatch: FD " << client_fd << ": Fetching '" << RequestMethodStr(request->method) << " " << entry->url() << "'" );
/*
@@ -1051,6 +1057,7 @@
}
}
#endif
+ ProfileProgress(Here);
if (servers && (p = servers->_peer)) {
p->stats.fetches++;
=== modified file 'src/http.cc'
--- src/http.cc 2010-09-28 17:43:42 +0000
+++ src/http.cc 2010-10-24 21:21:59 +0000
@@ -63,6 +63,43 @@
#include "SquidTime.h"
#include "Store.h"
+#if 0 // XXX: remove
+//#include "CodeTimer.h"
+timeval CodeTimerStart = { 0, 0};
+class CodeTimer {
+public:
+ CodeTimer(const char * const aStartName, const int aStartLine):
+ startName(aStartName), startLine(aStartLine)
+ {
+ if (!Depth++)
+ LastTime = CodeTimerStart;
+ tick(startName, startLine, "@beg ");
+ }
+ ~CodeTimer() { tick(startName, startLine, "@end "); --Depth; }
+
+ void tick(const char * const nowName, const int nowLine, const char * const prefix = "")
+ {
+ getCurrentTime();
+ int spent = -1;
+ if (LastTime.tv_sec > 0)
+ spent = tvSubUsec(LastTime, current_time);
+ else
+ if (CodeTimerStart.tv_sec > 0)
+ spent = tvSubUsec(CodeTimerStart, current_time);
+
+ if (CodeTimerStart.tv_sec > 0 || spent > 200)
+ debugs(1,1, nowName << ':' << nowLine << ": " << prefix << "spent: +" << spent);
+ LastTime = current_time;
+ }
+
+ const char * const startName;
+ const int startLine;
+ static timeval LastTime;
+ static int Depth;
+};
+timeval CodeTimer::LastTime = { 0, 0};
+int CodeTimer::Depth = 0;
+#endif
#define SQUID_ENTER_THROWING_CODE() try {
#define SQUID_EXIT_THROWING_CODE(status) \
@@ -85,6 +122,7 @@
lastChunk(0), header_bytes_read(0), reply_bytes_read(0),
body_bytes_truncated(0), httpChunkDecoder(NULL)
{
+ ProfileProgress(Here);
debugs(11,5,HERE << "HttpStateData " << this << " created");
ignoreCacheControl = false;
surrogateNoStore = false;
@@ -1077,6 +1115,8 @@
int clen;
int len = io.size;
+ ProfileProgress(Here);
+
assert(fd == io.fd);
flags.do_next_read = 0;
@@ -1115,6 +1155,7 @@
// update I/O stats
if (len > 0) {
readBuf->appended(len);
+ ProfileProgress(Here);
reply_bytes_read += len;
#if DELAY_POOLS
@@ -1137,6 +1178,8 @@
sent.tv_sec ? tvSubMsec(sent, current_time) : -1;
}
+ ProfileProgress(Here);
+
/** \par
* Here the RFC says we should ignore whitespace between replies, but we can't as
* doing so breaks HTTP/0.9 replies beginning with witespace, and in addition
@@ -1181,6 +1224,7 @@
}
}
+ ProfileProgress(Here);
processReply();
}
@@ -1190,6 +1234,8 @@
HttpStateData::processReply()
{
+ ProfileProgress(Here);
+
if (flags.handling1xx) { // we came back after handling a 1xx response
debugs(11, 5, HERE << "done with 1xx handling");
flags.handling1xx = false;
@@ -1199,11 +1245,13 @@
if (!flags.headers_parsed) { // have not parsed headers yet?
PROF_start(HttpStateData_processReplyHeader);
processReplyHeader();
+ ProfileProgress(Here);
PROF_stop(HttpStateData_processReplyHeader);
if (!continueAfterParsingHeader()) // parsing error or need more data
return; // TODO: send errors to ICAP
+ ProfileProgress(Here);
adaptOrFinalizeReply();
}
@@ -1312,10 +1360,13 @@
void
HttpStateData::writeReplyBody()
{
+ ProfileProgress(Here);
truncateVirginBody(); // if needed
const char *data = readBuf->content();
int len = readBuf->contentSize();
+ ProfileProgress(Here);
addVirginReplyBody(data, len);
+ ProfileProgress(Here);
readBuf->consume(len);
}
@@ -1352,6 +1403,8 @@
void
HttpStateData::processReplyBody()
{
+ ProfileProgress(Here);
+
AsyncCall::Pointer call;
Ip::Address client_addr;
bool ispinned = false;
@@ -1376,6 +1429,7 @@
*/
if (flags.chunked) {
if (!decodeAndWriteReplyBody()) {
+ ProfileProgress(Here);
flags.do_next_read = 0;
serverComplete();
return;
@@ -1383,6 +1437,7 @@
} else
writeReplyBody();
+ ProfileProgress(Here);
if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
/*
* The above writeReplyBody() call could ABORT this entry,
@@ -1413,6 +1468,8 @@
commSetTimeout(fd, -1, call);
flags.do_next_read = 0;
+ ProfileProgress(Here);
+
comm_remove_close_handler(fd, closeHandler);
closeHandler = NULL;
fwd->unregister(fd);
@@ -1436,6 +1493,7 @@
fd = -1;
+ ProfileProgress(Here);
serverComplete();
return;
@@ -1445,6 +1503,7 @@
return;
}
+ ProfileProgress(Here);
maybeReadVirginBody();
}
@@ -2026,6 +2085,7 @@
StoreEntry * sentry,
MemBuf * mb)
{
+ ProfileProgress(Here);
const int offset = mb->size;
HttpVersion httpver(1,1);
mb->Printf("%s %s HTTP/%d.%d\r\n",
@@ -2037,6 +2097,7 @@
HttpHeader hdr(hoRequest);
Packer p;
httpBuildRequestHeader(aRequest, original_request, sentry, &hdr, flags);
+ ProfileProgress(Here);
if (aRequest->flags.pinned && aRequest->flags.connection_auth)
aRequest->flags.auth_sent = 1;
@@ -2045,11 +2106,14 @@
packerToMemInit(&p, mb);
hdr.packInto(&p);
+ ProfileProgress(Here);
hdr.clean();
packerClean(&p);
+ ProfileProgress(Here);
}
/* append header terminator */
mb->append(crlf, 2);
+ ProfileProgress(Here);
return mb->size - offset;
}
@@ -2057,6 +2121,7 @@
bool
HttpStateData::sendRequest()
{
+ ProfileProgress(Here);
MemBuf mb;
debugs(11, 5, "httpSendRequest: FD " << fd << ", request " << request << ", this " << this << ".");
@@ -2074,6 +2139,7 @@
flags.do_next_read = 1;
maybeReadVirginBody();
+ ProfileProgress(Here);
if (orig_request->body_pipe != NULL) {
if (!startRequestBodyFlow()) // register to receive body data
return false;
@@ -2128,12 +2194,16 @@
flags.front_end_https = _peer->front_end_https;
}
+ ProfileProgress(Here);
+
mb.init();
request->peer_host=_peer?_peer->host:NULL;
buildRequestPrefix(request, orig_request, entry, &mb);
+ ProfileProgress(Here);
debugs(11, 6, "httpSendRequest: FD " << fd << ":\n" << mb.buf);
comm_write_mbuf(fd, &mb, requestSender);
+ ProfileProgress(Here);
return true;
}
=== modified file 'src/mem.cc'
--- src/mem.cc 2010-10-14 04:16:15 +0000
+++ src/mem.cc 2010-10-23 00:49:16 +0000
@@ -488,7 +488,11 @@
memClean(void)
{
MemPoolGlobalStats stats;
- MemPools::GetInstance().setIdleLimit(0);
+
+// XXX: restore
+// MemPools::GetInstance().setIdleLimit(0);
+// XXX
+
MemPools::GetInstance().clean(0);
memPoolGetGlobalStats(&stats);
=== modified file 'src/peer_select.cc'
--- src/peer_select.cc 2010-01-30 00:30:56 +0000
+++ src/peer_select.cc 2010-10-24 20:48:36 +0000
@@ -126,6 +126,7 @@
PSC * callback,
void *callback_data)
{
+ ProfileProgress(Here);
ps_state *psstate;
if (entry)
@@ -180,6 +181,7 @@
static void
peerSelectCallback(ps_state * psstate)
{
+ ProfileProgress(Here);
StoreEntry *entry = psstate->entry;
FwdServer *fs = psstate->servers;
PSC *callback;
@@ -261,6 +263,7 @@
static void
peerSelectFoo(ps_state * ps)
{
+ ProfileProgress(Here);
StoreEntry *entry = ps->entry;
HttpRequest *request = ps->request;
debugs(44, 3, "peerSelectFoo: '" << RequestMethodStr(request->method) << " " << request->GetHost() << "'");
@@ -305,6 +308,7 @@
debugs(44, 3, "peerSelectFoo: direct = " << DirectStr[ps->direct]);
}
+ ProfileProgress(Here);
if (!entry || entry->ping_status == PING_NONE)
peerSelectPinned(ps);
if (entry == NULL) {
@@ -345,6 +349,7 @@
}
peerSelectCallback(ps);
+ ProfileProgress(Here);
}
/*
@@ -762,6 +767,7 @@
static void
peerAddFwdServer(FwdServer ** FSVR, peer * p, hier_code code)
{
+ ProfileProgress(Here);
FwdServer *fs = (FwdServer *)memAllocate(MEM_FWD_SERVER);
debugs(44, 5, "peerAddFwdServer: adding " <<
(p ? p->host : "DIRECT") << " " <<
@@ -773,6 +779,7 @@
FSVR = &(*FSVR)->next;
*FSVR = fs;
+ ProfileProgress(Here);
}
void *
=== modified file 'src/stmem.cc'
--- src/stmem.cc 2009-03-06 13:26:57 +0000
+++ src/stmem.cc 2010-10-24 16:24:19 +0000
@@ -133,6 +133,7 @@
size_t
mem_hdr::writeAvailable(mem_node *aNode, int64_t location, size_t amount, char const *source)
{
+ ProfileProgress(Here);
/* if we attempt to overwrite existing data or leave a gap within a node */
assert (location == aNode->nodeBuffer.offset + (int64_t)aNode->nodeBuffer.length);
/* And we are not at the end of the node */
@@ -142,7 +143,9 @@
assert (location - aNode->nodeBuffer.offset == (int64_t)aNode->nodeBuffer.length);
size_t copyLen = min(amount, aNode->space());
+ ProfileProgress(Here);
xmemcpy(aNode->nodeBuffer.data + aNode->nodeBuffer.length, source, copyLen);
+ ProfileProgress(Here);
if (inmem_hi <= location)
inmem_hi = location + copyLen;
@@ -157,6 +160,7 @@
mem_hdr::appendNode (mem_node *aNode)
{
nodes.insert (aNode, NodeCompare);
+ ProfileProgress(Here);
}
void
@@ -325,10 +329,13 @@
mem_node *
mem_hdr::nodeToRecieve(int64_t offset)
{
+ ProfileProgress(Here);
+
/* case 1: Nothing in memory */
if (!nodes.size()) {
appendNode (new mem_node(offset));
+ ProfileProgress(Here);
return nodes.start()->data;
}
@@ -344,6 +351,7 @@
candidate = *leadup;
}
+ ProfileProgress(Here);
if (candidate && candidate->canAccept(offset))
return candidate;
@@ -351,6 +359,7 @@
candidate = new mem_node(offset);
appendNode (candidate);
+ ProfileProgress(Here);
/* simpler to write than a indented if */
return candidate;
@@ -360,6 +369,7 @@
bool
mem_hdr::write (StoreIOBuffer const &writeBuffer)
{
+ ProfileProgress(Here);
PROF_start(mem_hdr_write);
debugs(19, 6, "mem_hdr::write: " << writeBuffer.range() << " object end " << endOffset());
@@ -371,6 +381,7 @@
return false;
}
+ ProfileProgress(Here);
assert (writeBuffer.offset >= 0);
mem_node *target;
@@ -386,6 +397,7 @@
currentSource += wrote;
}
+ ProfileProgress(Here);
PROF_stop(mem_hdr_write);
return true;
}
=== modified file 'src/store.cc'
--- src/store.cc 2010-10-14 04:16:15 +0000
+++ src/store.cc 2010-10-25 04:03:29 +0000
@@ -379,6 +379,7 @@
void
StoreEntry::destroyMemObject()
{
+ ProfileScope(__FILE__, __LINE__, 0);
debugs(20, 3, HERE << "destroyMemObject " << mem_obj);
setMemStatus(NOT_IN_MEMORY);
MemObject *mem = mem_obj;
@@ -389,6 +390,7 @@
void
destroyStoreEntry(void *data)
{
+ ProfileScope(__FILE__, __LINE__, 0);
debugs(20, 3, HERE << "destroyStoreEntry: destroying " << data);
StoreEntry *e = static_cast<StoreEntry *>(static_cast<hash_link *>(data));
assert(e != NULL);
@@ -410,6 +412,7 @@
void
StoreEntry::hashInsert(const cache_key * someKey)
{
+ ProfileScope(__FILE__, __LINE__, 0);
debugs(20, 3, "StoreEntry::hashInsert: Inserting Entry " << this << " key '" << storeKeyText(someKey) << "'");
key = storeKeyDup(someKey);
hash_join(store_table, this);
@@ -418,6 +421,7 @@
void
StoreEntry::hashDelete()
{
+ ProfileScope(__FILE__, __LINE__, 0);
hash_remove_link(store_table, this);
storeKeyFree((const cache_key *)key);
key = NULL;
@@ -813,6 +817,8 @@
void
StoreEntry::write (StoreIOBuffer writeBuffer)
{
+ ProfileProgress(Here);
+
assert(mem_obj != NULL);
assert(writeBuffer.length >= 0);
/* This assert will change when we teach the store to update */
@@ -835,8 +841,11 @@
debugs(20, 5, "storeWrite: writing " << writeBuffer.length << " bytes for '" << getMD5Text() << "'");
PROF_stop(StoreEntry_write);
+ ProfileProgress(Here);
storeGetMemSpace(writeBuffer.length);
+ ProfileProgress(Here);
mem_obj->write (writeBuffer, storeWriteComplete, this);
+ ProfileProgress(Here);
}
/* Append incoming data from a primary server to an entry. */
@@ -1791,7 +1800,21 @@
assert (isEmpty());
- getReply()->packHeadersInto(&p);
+ // Pack header into a temporary buffer and then write the whole buffer
+ // at once to avoid hundreds of calls to mem_hdr::write() per header.
+ // While each call is relatively cheap, it is death by thousands cuts.
+ {
+ MemBuf hdrBuf;
+ hdrBuf.init();
+
+ Packer hdrPacker;
+ packerToMemInit(&hdrPacker, &hdrBuf);
+ getReply()->packHeadersInto(&hdrPacker);
+ packerClean(&hdrPacker);
+
+ if (hdrBuf.contentSize())
+ packerAppend(&p, hdrBuf.content(), hdrBuf.contentSize());
+ }
rep->hdr_sz = mem_obj->endOffset();
=== modified file 'src/store_client.cc'
--- src/store_client.cc 2010-04-07 09:49:57 +0000
+++ src/store_client.cc 2010-10-25 16:32:34 +0000
@@ -444,8 +444,11 @@
/* What the client wants is in memory */
/* Old style */
debugs(90, 3, "store_client::doCopy: Copying normal from memory");
+ ProfileProgress(Here);
size_t sz = entry->mem_obj->data_hdr.copy(copyInto);
+ ProfileProgress(Here);
callback(sz);
+ ProfileProgress(Here);
flags.store_copying = 0;
}
=== modified file 'src/tools.cc'
--- src/tools.cc 2010-09-23 17:58:15 +0000
+++ src/tools.cc 2010-10-20 16:35:09 +0000
@@ -424,7 +424,7 @@
if (state == 0) {
#if !MEM_GEN_TRACE
- Debug::parseOptions("ALL,7");
+ Debug::parseOptions("ALL,9");
#else
log_trace_done();