Performance improvements when running both in multi-threaded and pre-forked HTTPD. Changed memory management to use Apache APR pools instead of ref counting pointers as it's much faster and easier to integrate with the Python and Ruby interpreters. Changed to use simple pool-based string and stream implementations instead of the STL ones, which cause a lots of mutex locks in a multi-threaded environment. Added build options to compile with threading and profiling.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@895165 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 65 insertions, 61 deletions

diff --git a/sca-cpp/trunk/modules/server/mod-eval.cpp b/sca-cpp/trunk/modules/server/mod-eval.cpp
index d8354c6a58..8e8870dd52 100644
--- a/sca-cpp/trunk/modules/server/mod-eval.cpp
+++ b/sca-cpp/trunk/modules/server/mod-eval.cpp
@@ -23,15 +23,11 @@
  * HTTPD module used to eval component implementations.
  */
 
-#include <string>
-#include <iostream>
-#include <sstream>
-#include <fstream>
-
+#include "string.hpp"
+#include "stream.hpp"
 #include "function.hpp"
 #include "list.hpp"
 #include "tree.hpp"
-#include "slist.hpp"
 #include "value.hpp"
 #include "element.hpp"
 #include "monad.hpp"
@@ -58,9 +54,10 @@ class ServerConf {
 public:
     ServerConf(server_rec* s) : s(s), home(""), wiringServerName("") {
     }
+
     const server_rec* s;
-    std::string home;
-    std::string wiringServerName;
+    string home;
+    string wiringServerName;
 };
 
 /**
@@ -71,8 +68,8 @@ public:
     DirConf(char* dirspec) : dirspec(dirspec), contributionPath(""), compositeName("") {
     }
     const char* dirspec;
-    std::string contributionPath;
-    std::string compositeName;
+    string contributionPath;
+    string compositeName;
     list<value> implementations;
 };
 
@@ -80,16 +77,16 @@ public:
  * Convert a result represented as a content + failure pair to a
  * failable monad.
  */
-const failable<value, std::string> failableResult(const list<value>& v) {
+const failable<value> failableResult(const list<value>& v) {
     if (isNil(cdr(v)))
         return car(v);
-    return mkfailure<value, std::string>(cadr(v));
+    return mkfailure<value>(string(cadr(v)));
 }
 
 /**
  * Handle an HTTP GET.
  */
-const failable<int, std::string> get(request_rec* r, const lambda<value(const list<value>&)>& impl) {
+const failable<int> get(request_rec* r, const lambda<value(const list<value>&)>& impl) {
     debug(r->uri, "modeval::get::uri");
 
     // Inspect the query string
@@ -102,12 +99,12 @@ const failable<int, std::string> get(request_rec* r, const lambda<value(const li
 
         // Extract the request id, method and params
         const value id = cadr(ia);
-        const value func = std::string(cadr(ma)).c_str();
+        const value func = c_str(string(cadr(ma)));
 
         // Apply the requested function
-        const failable<value, std::string> val = failableResult(impl(cons(func, httpd::queryParams(args))));
+        const failable<value> val = failableResult(impl(cons(func, httpd::queryParams(args))));
         if (!hasContent(val))
-            return mkfailure<int, std::string>(reason(val));
+            return mkfailure<int>(reason(val));
 
         // Return JSON result
         json::JSONContext cx;
@@ -115,58 +112,58 @@ const failable<int, std::string> get(request_rec* r, const lambda<value(const li
     }
 
     // Evaluate an ATOM GET request and return an ATOM feed
-    const list<value> path(httpd::path(r->uri));
+    const list<value> path(httpd::pathValues(r->uri));
     if (isNil(cddr(path))) {
-        const failable<value, std::string> val = failableResult(impl(cons<value>("getall", list<value>())));
+        const failable<value> val = failableResult(impl(cons<value>("getall", list<value>())));
         if (!hasContent(val))
-            return mkfailure<int, std::string>(reason(val));
+            return mkfailure<int>(reason(val));
         return httpd::writeResult(atom::writeATOMFeed(atom::feedValuesToElements(content(val))), "application/atom+xml;type=feed", r);
     }
 
     // Evaluate an ATOM GET and return an ATOM entry
-    const failable<value, std::string> val = failableResult(impl(cons<value>("get", mklist<value>(caddr(path)))));
+    const failable<value> val = failableResult(impl(cons<value>("get", mklist<value>(caddr(path)))));
     if (!hasContent(val))
-        return mkfailure<int, std::string>(reason(val));
+        return mkfailure<int>(reason(val));
     return httpd::writeResult(atom::writeATOMEntry(atom::entryValuesToElements(content(val))), "application/atom+xml;type=entry", r);
 }
 
 /**
  * Handle an HTTP POST.
  */
-const failable<int, std::string> post(request_rec* r, const lambda<value(const list<value>&)>& impl) {
-    const list<std::string> ls = httpd::read(r);
+const failable<int> post(request_rec* r, const lambda<value(const list<value>&)>& impl) {
+    const list<string> ls = httpd::read(r);
     debug(r->uri, "modeval::post::url");
     debug(ls, "modeval::post::input");
 
     // Evaluate a JSON-RPC request and return a JSON result
-    const std::string ct = httpd::contentType(r);
-    if (ct.find("application/json-rpc") != std::string::npos || ct.find("text/plain") != std::string::npos) {
+    const string ct = httpd::contentType(r);
+    if (contains(ct, "application/json-rpc") || contains(ct, "text/plain")) {
         json::JSONContext cx;
         const list<value> json = elementsToValues(content(json::readJSON(ls, cx)));
         const list<list<value> > args = httpd::postArgs(json);
 
         // Extract the request id, method and params
         const value id = cadr(assoc(value("id"), args));
-        const value func = std::string(cadr(assoc(value("method"), args))).c_str();
+        const value func = c_str(cadr(assoc(value("method"), args)));
         const list<value> params = (list<value>)cadr(assoc(value("params"), args));
 
         // Evaluate the request expression
-        const failable<value, std::string> val = failableResult(impl(cons<value>(func, params)));
+        const failable<value> val = failableResult(impl(cons<value>(func, params)));
         if (!hasContent(val))
-            return mkfailure<int, std::string>(reason(val));
+            return mkfailure<int>(reason(val));
 
         // Return JSON result
         return httpd::writeResult(json::jsonResult(id, content(val), cx), "application/json-rpc", r);
     }
 
     // Evaluate an ATOM POST request and return the created resource location
-    if (ct.find("application/atom+xml") != std::string::npos) {
+    if (contains(ct, "application/atom+xml")) {
 
         // Evaluate the request expression
         const value entry = atom::entryValue(content(atom::readEntry(ls)));
-        const failable<value, std::string> val = failableResult(impl(cons<value>("post", mklist<value>(entry))));
+        const failable<value> val = failableResult(impl(cons<value>("post", mklist<value>(entry))));
         if (!hasContent(val))
-            return mkfailure<int, std::string>(reason(val));
+            return mkfailure<int>(reason(val));
 
         // Return the created resource location
         apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, httpd::url(content(val), r)));
@@ -180,17 +177,17 @@ const failable<int, std::string> post(request_rec* r, const lambda<value(const l
 /**
  * Handle an HTTP PUT.
  */
-const failable<int, std::string> put(request_rec* r, const lambda<value(const list<value>&)>& impl) {
-    const list<std::string> ls = httpd::read(r);
+const failable<int> put(request_rec* r, const lambda<value(const list<value>&)>& impl) {
+    const list<string> ls = httpd::read(r);
     debug(r->uri, "modeval::put::url");
     debug(ls, "modeval::put::input");
 
     // Evaluate an ATOM PUT request
-    const list<value> path(httpd::path(r->uri));
+    const list<value> path(httpd::pathValues(r->uri));
     const value entry = atom::entryValue(content(atom::readEntry(ls)));
-    const failable<value, std::string> val = failableResult(impl(cons<value>("put", mklist<value>(caddr(path), entry))));
+    const failable<value> val = failableResult(impl(cons<value>("put", mklist<value>(caddr(path), entry))));
     if (!hasContent(val))
-        return mkfailure<int, std::string>(reason(val));
+        return mkfailure<int>(reason(val));
     if (val == value(false))
         return HTTP_NOT_FOUND;
     return OK;
@@ -199,14 +196,14 @@ const failable<int, std::string> put(request_rec* r, const lambda<value(const li
 /**
  * Handle an HTTP DELETE.
  */
-const failable<int, std::string> del(request_rec* r, const lambda<value(const list<value>&)>& impl) {
+const failable<int> del(request_rec* r, const lambda<value(const list<value>&)>& impl) {
     debug(r->uri, "modeval::delete::url");
 
     // Evaluate an ATOM delete request
-    const list<value> path(httpd::path(r->uri));
-    const failable<value, std::string> val = failableResult(impl(cons<value>("delete", mklist<value>(caddr(path)))));
+    const list<value> path(httpd::pathValues(r->uri));
+    const failable<value> val = failableResult(impl(cons<value>("delete", mklist<value>(caddr(path)))));
     if (!hasContent(val))
-        return mkfailure<int, std::string>(reason(val));
+        return mkfailure<int>(reason(val));
     if (val == value(false))
         return HTTP_NOT_FOUND;
     return OK;
@@ -216,6 +213,7 @@ const failable<int, std::string> del(request_rec* r, const lambda<value(const li
  * Translate a component request.
  */
 int translate(request_rec *r) {
+    gc_scoped_pool pool(r->pool);
     if (strncmp(r->uri, "/components/", 12) != 0)
         return DECLINED;
     r->handler = "mod_tuscany_eval";
@@ -226,6 +224,7 @@ int translate(request_rec *r) {
  * HTTP request handler.
  */
 int handler(request_rec *r) {
+    gc_scoped_pool pool(r->pool);
     if(strcmp(r->handler, "mod_tuscany_eval"))
         return DECLINED;
     httpdDebugRequest(r, "modeval::handler::input");
@@ -237,7 +236,7 @@ int handler(request_rec *r) {
 
     // Get the component implementation lambda
     DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_eval);
-    const list<value> path(httpd::path(r->uri));
+    const list<value> path(httpd::pathValues(r->uri));
     const list<value> impl(assoctree<value>(cadr(path), dc.implementations));
     if (isNil(impl))
         return HTTP_NOT_FOUND;
@@ -260,11 +259,11 @@ int handler(request_rec *r) {
 /**
  * Convert a list of component references to a list of HTTP proxy lambdas.
  */
-const value mkproxy(const value& ref, const std::string& base) {
-    return lambda<value(const list<value>&)>(http::proxy(base + std::string(scdl::name(ref))));
+const value mkproxy(const value& ref, const string& base) {
+    return lambda<value(const list<value>&)>(http::proxy(base + string(scdl::name(ref))));
 }
 
-const list<value> proxies(const list<value>& refs, const std::string& base) {
+const list<value> proxies(const list<value>& refs, const string& base) {
     if (isNil(refs))
         return refs;
     return cons(mkproxy(car(refs), base), proxies(cdr(refs), base));
@@ -274,31 +273,31 @@ const list<value> proxies(const list<value>& refs, const std::string& base) {
  * Return a configured component implementation.
  * For now only Scheme and C++ implementations are supported.
  */
-const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string& itype, const std::string& path, const list<value>& px) {
-    if (itype.find(".scheme") != std::string::npos)
+const failable<lambda<value(const list<value>&)> > readImplementation(const string& itype, const string& path, const list<value>& px) {
+    if (contains(itype, ".scheme"))
         return scm::readImplementation(path, px);
-    if (itype.find(".cpp") != std::string::npos)
+    if (contains(itype, ".cpp"))
         return cpp::readImplementation(path, px);
-    return mkfailure<lambda<value(const list<value>&)>, std::string>("Unsupported implementation type: " + itype);
+    return mkfailure<lambda<value(const list<value>&)> >(string("Unsupported implementation type: ") + itype);
 }
 
 const value confImplementation(DirConf& dc, ServerConf& sc, server_rec& server, const value& comp) {
     const value impl = scdl::implementation(comp);
-    const std::string path = dc.contributionPath + std::string(scdl::uri(impl));
+    const string path = dc.contributionPath + string(scdl::uri(impl));
 
     // Convert component references to configured proxy lambdas
-    std::ostringstream base;
+    ostringstream base;
     if (sc.wiringServerName == "")
         base << (server.server_scheme == NULL? "http" : server.server_scheme)
             << "://" << (server.server_hostname == NULL? "localhost" : server.server_hostname)
             << ":" << (server.port == 0? 80 : server.port)
-            << "/references/" << std::string(scdl::name(comp)) << "/";
+            << "/references/" << string(scdl::name(comp)) << "/";
     else
-        base << sc.wiringServerName << "/references/" << std::string(scdl::name(comp)) << "/";
-    const list<value> px(proxies(scdl::references(comp), base.str()));
+        base << sc.wiringServerName << "/references/" << string(scdl::name(comp)) << "/";
+    const list<value> px(proxies(scdl::references(comp), str(base)));
 
     // Read and configure the implementation
-    const failable<lambda<value(const list<value>&)>, std::string> cimpl(readImplementation(elementName(impl), path, px));
+    const failable<lambda<value(const list<value>&)> > cimpl(readImplementation(elementName(impl), path, px));
     if (!hasContent(cimpl))
         return reason(cimpl);
     return content(cimpl);
@@ -320,10 +319,10 @@ const list<value> componentToImplementationTree(DirConf& dc, ServerConf& sc, ser
 /**
  * Read the components declared in a composite.
  */
-const failable<list<value>, std::string> readComponents(const std::string& path) {
-    std::ifstream is(path);
-    if (is.fail() || is.bad())
-        return mkfailure<list<value>, std::string>("Could not read composite: " + path);
+const failable<list<value> > readComponents(const string& path) {
+    ifstream is(path);
+    if (fail(is))
+        return mkfailure<list<value> >(string("Could not read composite: ") + path);
     return scdl::components(readXML(streamList(is)));
 }
 
@@ -333,7 +332,7 @@ const failable<list<value>, std::string> readComponents(const std::string& path)
 const bool confComponents(DirConf& dc, ServerConf& sc, server_rec& server) {
     if (dc.contributionPath == "" || dc.compositeName == "")
         return true;
-    const failable<list<value>, std::string> comps = readComponents(dc.contributionPath + dc.compositeName);
+    const failable<list<value> > comps = readComponents(dc.contributionPath + dc.compositeName);
     if (!hasContent(comps))
         return true;
     dc.implementations = componentToImplementationTree(dc, sc, server, content(comps));
@@ -345,16 +344,19 @@ const bool confComponents(DirConf& dc, ServerConf& sc, server_rec& server) {
  * Configuration commands.
  */
 const char *confHome(cmd_parms *cmd, unused void *c, const char *arg) {
+    gc_scoped_pool pool(cmd->pool);
     ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval);
     sc.home = arg;
     return NULL;
 }
 const char *confWiringServerName(cmd_parms *cmd, unused void *c, const char *arg) {
+    gc_scoped_pool pool(cmd->pool);
     ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval);
     sc.wiringServerName = arg;
     return NULL;
 }
 const char *confContribution(cmd_parms *cmd, void *c, const char *arg) {
+    gc_scoped_pool pool(cmd->pool);
     ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval);
     DirConf& dc = *(DirConf*)c;
     dc.contributionPath = arg;
@@ -362,6 +364,7 @@ const char *confContribution(cmd_parms *cmd, void *c, const char *arg) {
     return NULL;
 }
 const char *confComposite(cmd_parms *cmd, void *c, const char *arg) {
+    gc_scoped_pool pool(cmd->pool);
     ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval);
     DirConf& dc = *(DirConf*)c;
     dc.compositeName = arg;
@@ -384,10 +387,11 @@ int postConfig(unused apr_pool_t *p, unused apr_pool_t *plog, unused apr_pool_t
     return OK;
 }
 
-void childInit(unused apr_pool_t* p, server_rec* svr_rec) {
+void childInit(apr_pool_t* p, server_rec* svr_rec) {
+    gc_scoped_pool pool(p);
     ServerConf* c = (ServerConf*)ap_get_module_config(svr_rec->module_config, &mod_tuscany_eval);
     if(c == NULL) {
-        std::cerr << "[Tuscany] Due to one or more errors mod_tuscany_eval loading failed. Causing apache to stop loading." << std::endl;
+        cerr << "[Tuscany] Due to one or more errors mod_tuscany_eval loading failed. Causing apache to stop loading." << endl;
         exit(APEXIT_CHILDFATAL);
     }
 }