add Recycle event methods

3 files changed, 31 insertions, 30 deletions

diff --git a/internal/eventloop.go b/internal/eventloop.go
index f3762b0..26d7a17 100644
--- a/internal/eventloop.go
+++ b/internal/eventloop.go
@@ -31,15 +31,15 @@ func eventLoop(bpfModule *bpf.Module, ch <-chan []byte) {
 			enterEv, ok := enterOpen[ev.PidTgid]
 			if !ok {
 				fmt.Println("Dropping", ev)
-				RecycleFdEvent(ev)
+				ev.Recycle()
 				continue
 			}
 			duration := float64(ev.Time-enterEv.Time) / float64(1_000_000)
 			fmt.Println(duration, "ms", enterEv, ev)
 
 			delete(enterOpen, ev.PidTgid)
-			RecycleFdEvent(ev)
-			RecycleOpenEnterEvent(enterEv)
+			ev.Recycle()
+			enterEv.Recycle()
 
 		case CLOSE_ENTER_OP_ID:
 			fallthrough
@@ -58,15 +58,15 @@ func eventLoop(bpfModule *bpf.Module, ch <-chan []byte) {
 			enterEv, ok := enterFd[ev.PidTgid]
 			if !ok {
 				fmt.Println("Dropping", ev)
-				RecycleNullEvent(ev)
+				ev.Recycle()
 				continue
 			}
 			duration := float64(ev.Time-enterEv.Time) / float64(1_000_000)
 			fmt.Println(duration, "ms", enterEv, ev)
 
 			delete(enterFd, ev.PidTgid)
-			RecycleNullEvent(ev)
-			RecycleFdEvent(enterEv)
+			ev.Recycle()
+			enterEv.Recycle()
 
 		default:
 			panic(fmt.Sprintf("UNKNOWN Ringbuf data received len:%d raw:%v", len(raw), raw))
diff --git a/internal/generated/nqc.raku b/internal/generated/nqc.raku
index 1c48cba..24771cf 100644
--- a/internal/generated/nqc.raku
+++ b/internal/generated/nqc.raku
@@ -97,6 +97,7 @@ class NQCToGoActions {
 
     method !struct-go-sync-pool($/) returns Str {
         my Str $identifier = $/<identifier>.made;
+        my Str $self-ref = $identifier.lc.substr(0,1);
 
         qq:to/END/;
         var poolOf{$identifier}s = sync.Pool\{
@@ -104,16 +105,16 @@ class NQCToGoActions {
 	\}
 
         func New{$identifier}(raw []byte) *$identifier \{
-            ev := poolOf{$identifier}s.Get().(*$identifier);
-	    if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, ev); err != nil \{
-		fmt.Println(ev, raw, len(raw), err)
+            $self-ref := poolOf{$identifier}s.Get().(*$identifier);
+	    if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, $self-ref); err != nil \{
+		fmt.Println($self-ref, raw, len(raw), err)
 		panic(raw)
             \}
-	    return ev
+	    return $self-ref
         \}
 
-        func Recycle{$identifier}(elem *$identifier) \{
-            poolOf{$identifier}s.Put(elem)
+        func ($self-ref *$identifier) Recycle() \{
+            poolOf{$identifier}s.Put($self-ref)
         \}
         END
     }
diff --git a/internal/generated/types/types.go b/internal/generated/types/types.go
index 9d7fcb8..1e51ebe 100644
--- a/internal/generated/types/types.go
+++ b/internal/generated/types/types.go
@@ -65,16 +65,16 @@ var poolOfNullEvents = sync.Pool{
 }
 
 func NewNullEvent(raw []byte) *NullEvent {
-	ev := poolOfNullEvents.Get().(*NullEvent)
-	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, ev); err != nil {
-		fmt.Println(ev, raw, len(raw), err)
+	n := poolOfNullEvents.Get().(*NullEvent)
+	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, n); err != nil {
+		fmt.Println(n, raw, len(raw), err)
 		panic(raw)
 	}
-	return ev
+	return n
 }
 
-func RecycleNullEvent(elem *NullEvent) {
-	poolOfNullEvents.Put(elem)
+func (n *NullEvent) Recycle() {
+	poolOfNullEvents.Put(n)
 }
 
 type FdEvent struct {
@@ -93,16 +93,16 @@ var poolOfFdEvents = sync.Pool{
 }
 
 func NewFdEvent(raw []byte) *FdEvent {
-	ev := poolOfFdEvents.Get().(*FdEvent)
-	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, ev); err != nil {
-		fmt.Println(ev, raw, len(raw), err)
+	f := poolOfFdEvents.Get().(*FdEvent)
+	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, f); err != nil {
+		fmt.Println(f, raw, len(raw), err)
 		panic(raw)
 	}
-	return ev
+	return f
 }
 
-func RecycleFdEvent(elem *FdEvent) {
-	poolOfFdEvents.Put(elem)
+func (f *FdEvent) Recycle() {
+	poolOfFdEvents.Put(f)
 }
 
 type OpenEnterEvent struct {
@@ -122,16 +122,16 @@ var poolOfOpenEnterEvents = sync.Pool{
 }
 
 func NewOpenEnterEvent(raw []byte) *OpenEnterEvent {
-	ev := poolOfOpenEnterEvents.Get().(*OpenEnterEvent)
-	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, ev); err != nil {
-		fmt.Println(ev, raw, len(raw), err)
+	o := poolOfOpenEnterEvents.Get().(*OpenEnterEvent)
+	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, o); err != nil {
+		fmt.Println(o, raw, len(raw), err)
 		panic(raw)
 	}
-	return ev
+	return o
 }
 
-func RecycleOpenEnterEvent(elem *OpenEnterEvent) {
-	poolOfOpenEnterEvents.Put(elem)
+func (o *OpenEnterEvent) Recycle() {
+	poolOfOpenEnterEvents.Put(o)
 }
 
 type Flags struct {