prof: simple profile some mem alloc

_examples/pprof-cli.go

@@ -12,9 +12,9 @@ import (
 // run serve:
 // 	go run ./_examples/pprof-cli.go
 // see prof on cli:
-// 	go tool pprof rux_prof_data.prof
+// 	go tool pprof rux_cpu.prof
 // see prof on web:
-// 	go tool pprof -http=:8080 rux_prof_data.prof
+// 	go tool pprof -http=:8080 rux_cpu.prof
 func main() {
 	// rux.Debug(true)
 	r := rux.New()
@@ -30,7 +30,7 @@ func main() {
 	times := 1000000
 	fmt.Println("start profile, run times:", times)
 
-	ruxProfile := "rux_prof_data.prof"
+	ruxProfile := "rux_cpu.prof"
 	f, err := os.Create(ruxProfile)
 	if err != nil {
 		log.Fatal(err)
@@ -51,5 +51,6 @@ func main() {
 		// fmt.Println(ret)
 	}
 
-	fmt.Println("see prof on web:\n  go tool pprof -http=:8080 rux_prof_data.prof")
+	fmt.Println("see prof on cli:\n  go tool pprof", ruxProfile)
+	fmt.Println("see prof on web:\n  go tool pprof -http=:8080", ruxProfile)
 }

benchmark_test.go

@@ -113,6 +113,43 @@ func TestMultiMatchAtOnce(t *testing.T) {
 	fmt.Println(ret)
 }
 
+/*************************************************************
+ * test allocs
+ *************************************************************/
+
+func TestAlloc_formatPath(t *testing.T) {
+	r := New()
+	r.GET("/page/{id}", emptyHandler)
+	r.GET("/blog/{id}", emptyHandler)
+
+	fmt.Println("Alloc Times:", int(testing.AllocsPerRun(100, func() {
+		// r.formatPath("/blog/100")
+		r.formatPath("/blog/100/")
+	})))
+}
+
+func TestAlloc_match_static(t *testing.T) {
+	r := New()
+	r.GET("/page/{id}", emptyHandler)
+	r.GET("/blog/{id}", emptyHandler)
+	r.GET("/about", emptyHandler)
+
+	// output: 0 times
+	fmt.Println("Alloc Times:", int(testing.AllocsPerRun(100, func() {
+		r.match(GET, "/about")
+	})))
+}
+
+func TestAlloc_match_regular(t *testing.T) {
+	r := New()
+	r.GET("/page/{id}", emptyHandler)
+	r.GET("/blog/{id}", emptyHandler)
+
+	fmt.Println("Alloc Times:", int(testing.AllocsPerRun(100, func() {
+		r.match(GET, "/blog/100")
+	})))
+}
+
 /*************************************************************
  * helper methods(ref the gin framework)
  *************************************************************/

issues_test.go

@@ -18,7 +18,7 @@ func TestIssue_60(t *testing.T)  {
 
 	route, _, _ := r.Match("GET", "/blog/100")
 	is.NotEmpty(route)
-	dump.P(route.Info())
+	// dump.P(route.Info())
 
 	route, _, _ = r.Match("GET", "/blog/100/")
 	is.NotEmpty(route)

parse_match.go

@@ -145,34 +145,33 @@ func (r *Router) QuickMatch(method, path string) (route *Route, ps Params, alm [
 
 func (r *Router) match(method, path string) (rt *Route, ps Params) {
 	// find in stable routes
-	key := method + path
-	if route, ok := r.stableRoutes[key]; ok {
+	if route, ok := r.stableRoutes[method + path]; ok {
 		// return r.newMatchResult(route, nil)
 		return route, nil
 	}
 
 	// find in cached routes
 	if r.enableCaching {
-		route, ok := r.cachedRoutes.Get(key)
+		route, ok := r.cachedRoutes.Get(method + path)
 		if ok {
 			return route, route.params
 		}
 	}
 
 	// find in regular routes
 	if pos := strings.IndexByte(path[1:], '/'); pos > 0 {
-		key = method + path[1:pos+1]
+		key := method + path[1:pos+1]
 
 		if rs, ok := r.regularRoutes[key]; ok {
-			for _, route := range rs {
-				if strings.Index(path, route.start) != 0 {
+			for i,_ := range rs {
+				if strings.Index(path, rs[i].start) != 0 {
 					continue
 				}
 
-				if ps, ok := route.matchRegex(path); ok {
+				if ps, ok := rs[i].matchRegex(path); ok {
 					// ret = r.newMatchResult(route, ps)
-					r.cacheDynamicRoute(key, ps, route)
-					return route, ps
+					r.cacheDynamicRoute(key, ps, rs[i])
+					return rs[i], ps
 				}
 			}
 		}
@@ -182,7 +181,7 @@ func (r *Router) match(method, path string) (rt *Route, ps Params) {
 	if rs, ok := r.irregularRoutes[method]; ok {
 		for _, route := range rs {
 			if ps, ok := route.matchRegex(path); ok {
-				r.cacheDynamicRoute(key, ps, route)
+				r.cacheDynamicRoute(method + path, ps, route)
 				return route, ps
 			}
 		}

route.go

@@ -88,7 +88,7 @@ type Route struct {
 // NewRoute create a new route
 func NewRoute(path string, handler HandlerFunc, methods ...string) *Route {
 	return &Route{
-		path: strings.TrimSpace(path),
+		path: simpleFmtPath(path),
 		// handler
 		handler: handler,
 		methods: formatMethodsWithDefault(methods, GET),
@@ -105,7 +105,7 @@ func NamedRoute(name, path string, handler HandlerFunc, methods ...string) *Rout
 func NewNamedRoute(name, path string, handler HandlerFunc, methods ...string) *Route {
 	return &Route{
 		name: strings.TrimSpace(name),
-		path: strings.TrimSpace(path),
+		path: simpleFmtPath(path),
 		// handler
 		handler: handler,
 		methods: formatMethodsWithDefault(methods, GET),

router.go

@@ -82,7 +82,7 @@ type Router struct {
 	enableCaching bool
 	// use encoded path for match route. default is False
 	useEncodedPath bool
-	// strict check last slash char('/'). If is True, will strict compare last '/'. default is False
+	// strict match last slash char('/'). If is True, will strict compare last '/'. default is False
 	strictLastSlash bool
 	// the max memory limit for multipart forms
 	// maxMultipartMemory int64
@@ -470,9 +470,9 @@ func (r *Router) formatPath(path string) string {
 	}
 
 	path = strings.TrimSpace(path)
-	// clear last '/'
+	// clear last slash: '/'
 	if !r.strictLastSlash && path[len(path)-1] == '/' {
-		path = strings.TrimRight(path, "/")
+		path = strings.TrimRight(path, "/") // TODO alloc 1 times
 	}
 
 	if path == "" || path == "/" {

utils.go

@@ -49,6 +49,16 @@ func isFixedPath(s string) bool {
 	return strings.IndexByte(s, '{') < 0 && strings.IndexByte(s, '[') < 0
 }
 
+func simpleFmtPath(path string) string  {
+	path = strings.TrimSpace(path)
+
+	if path == "" {
+		return "/"
+	}
+
+	return "/" + strings.TrimLeft(path, "/")
+}
+
 func resolveAddress(addr []string) (fullAddr string) {
 	ip := "0.0.0.0"
 	switch len(addr) {