highperfocused/go-nostr
1
0
Fork 0
mirror of https://github.com/nbd-wtf/go-nostr.git synced 2025-07-07 14:49:56 +02:00
Code Issues Packages Projects Releases Wiki Activity

make simdjson great again.

Browse Source 
now it is generally a little faster than the easyjson approach.

goos: linux
goarch: amd64
pkg: github.com/nbd-wtf/go-nostr
cpu: AMD Ryzen 3 3200G with Radeon Vega Graphics
BenchmarkParseMessage/stdlib-4         	      90	  15616341 ns/op
BenchmarkParseMessage/easyjson-4       	     110	  11306466 ns/op
BenchmarkParseMessage/simdjson-4       	     162	   7779856 ns/op
PASS
ok  	github.com/nbd-wtf/go-nostr	5.547s
This commit is contained in:
fiatjaf
2025-03-05 23:42:16 -03:00
parent de358e641c
commit 4fb6fcd9a2
6 changed files with 258 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
envelopes.go
View File

@ -9,7 +9,6 @@ import (
"github.com/mailru/easyjson"
jwriter "github.com/mailru/easyjson/jwriter"
"github.com/minio/simdjson-go"
"github.com/tidwall/gjson"
)
@ -27,55 +26,6 @@ var (
UnknownLabel = errors.New("unknown envelope label")
)
// ParseMessageSIMD parses a message using the experimental simdjson-go library.
func ParseMessageSIMD(message []byte, reuse *simdjson.ParsedJson) (Envelope, error) {
parsed, err := simdjson.Parse(message, reuse)
if err != nil {
return nil, fmt.Errorf("simdjson parse failed: %w", err)
}
iter := parsed.Iter()
iter.AdvanceInto()
if t := iter.Advance(); t != simdjson.TypeArray {
return nil, fmt.Errorf("top-level must be an array")
}
arr, _ := iter.Array(nil)
iter = arr.Iter()
iter.Advance()
label, _ := iter.StringBytes()
var v EnvelopeSIMD
switch {
case bytes.Equal(label, labelEvent):
v = &EventEnvelope{}
case bytes.Equal(label, labelReq):
v = &ReqEnvelope{}
case bytes.Equal(label, labelCount):
v = &CountEnvelope{}
case bytes.Equal(label, labelNotice):
x := NoticeEnvelope("")
v = &x
case bytes.Equal(label, labelEose):
x := EOSEEnvelope("")
v = &x
case bytes.Equal(label, labelOk):
v = &OKEnvelope{}
case bytes.Equal(label, labelAuth):
v = &AuthEnvelope{}
case bytes.Equal(label, labelClosed):
v = &ClosedEnvelope{}
case bytes.Equal(label, labelClose):
x := CloseEnvelope("")
v = &x
default:
return nil, UnknownLabel
}
err = v.UnmarshalSIMD(iter)
return v, err
}
// ParseMessage parses a message into an Envelope.
func ParseMessage(message []byte) Envelope {
firstComma := bytes.Index(message, []byte{','})
@ -125,12 +75,6 @@ type Envelope interface {
String() string
}
// EnvelopeSIMD extends Envelope with SIMD unmarshaling capability.
type EnvelopeSIMD interface {
Envelope
UnmarshalSIMD(simdjson.Iter) error
}
var (
_ Envelope = (*EventEnvelope)(nil)
_ Envelope = (*ReqEnvelope)(nil)
@ -164,25 +108,6 @@ func (v *EventEnvelope) UnmarshalJSON(data []byte) error {
}
}
func (v *EventEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
// we may or may not have a subscription ID, so peek
if iter.PeekNext() == simdjson.TypeString {
iter.Advance()
// we have a subscription ID
subID, err := iter.String()
if err != nil {
return err
}
v.SubscriptionID = &subID
}
// now get the event
if typ := iter.Advance(); typ == simdjson.TypeNone {
return fmt.Errorf("missing event")
}
return v.Event.UnmarshalSIMD(&iter)
}
func (v EventEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["EVENT",`)
@ -223,44 +148,6 @@ func (v *ReqEnvelope) UnmarshalJSON(data []byte) error {
return nil
}
func (v *ReqEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
var err error
// we must have a subscription id
if typ := iter.Advance(); typ == simdjson.TypeString {
v.SubscriptionID, err = iter.String()
if err != nil {
return err
}
} else {
return fmt.Errorf("unexpected %s for REQ subscription id", typ)
}
// now get the filters
v.Filters = make(Filters, 0, 1)
tempIter := &simdjson.Iter{} // make a new iterator here because there may come multiple filters
for {
if typ, err := iter.AdvanceIter(tempIter); err != nil {
return err
} else if typ == simdjson.TypeNone {
break
} else {
}
var filter Filter
if err := filter.UnmarshalSIMD(tempIter); err != nil {
return err
}
v.Filters = append(v.Filters, filter)
}
if len(v.Filters) == 0 {
return fmt.Errorf("need at least one filter")
}
return nil
}
func (v ReqEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["REQ","`)
@ -326,53 +213,6 @@ func (v *CountEnvelope) UnmarshalJSON(data []byte) error {
return nil
}
func (v *CountEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
var err error
// this has two cases:
// in the first case (request from client) this is like REQ except with always one filter
// in the other (response from relay) we have a json object response
// but both cases start with a subscription id
if typ := iter.Advance(); typ == simdjson.TypeString {
v.SubscriptionID, err = iter.String()
if err != nil {
return err
}
} else {
return fmt.Errorf("unexpected %s for COUNT subscription id", typ)
}
// now get either a single filter or stuff from the json object
if typ := iter.Advance(); typ == simdjson.TypeNone {
return fmt.Errorf("missing json object")
}
if el, err := iter.FindElement(nil, "count"); err == nil {
c, _ := el.Iter.Uint()
count := int64(c)
v.Count = &count
if el, err = iter.FindElement(nil, "hll"); err == nil {
if hllHex, err := el.Iter.StringBytes(); err != nil || len(hllHex) != 512 {
return fmt.Errorf("hll is malformed")
} else {
v.HyperLogLog = make([]byte, 256)
if _, err := hex.Decode(v.HyperLogLog, hllHex); err != nil {
return fmt.Errorf("hll is invalid hex")
}
}
}
} else {
var filter Filter
if err := filter.UnmarshalSIMD(&iter); err != nil {
return err
}
v.Filters = Filters{filter}
}
return nil
}
func (v CountEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["COUNT","`)
@ -418,14 +258,6 @@ func (v *NoticeEnvelope) UnmarshalJSON(data []byte) error {
return nil
}
func (v *NoticeEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
if typ := iter.Advance(); typ == simdjson.TypeString {
msg, _ := iter.String()
*v = NoticeEnvelope(msg)
}
return nil
}
func (v NoticeEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["NOTICE",`)
@ -453,14 +285,6 @@ func (v *EOSEEnvelope) UnmarshalJSON(data []byte) error {
return nil
}
func (v *EOSEEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
if typ := iter.Advance(); typ == simdjson.TypeString {
msg, _ := iter.String()
*v = EOSEEnvelope(msg)
}
return nil
}
func (v EOSEEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["EOSE",`)
@ -490,14 +314,6 @@ func (v *CloseEnvelope) UnmarshalJSON(data []byte) error {
}
}
func (v *CloseEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
if typ := iter.Advance(); typ == simdjson.TypeString {
msg, _ := iter.String()
*v = CloseEnvelope(msg)
}
return nil
}
func (v CloseEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["CLOSE",`)
@ -530,16 +346,6 @@ func (v *ClosedEnvelope) UnmarshalJSON(data []byte) error {
}
}
func (v *ClosedEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
if typ := iter.Advance(); typ == simdjson.TypeString {
v.SubscriptionID, _ = iter.String()
}
if typ := iter.Advance(); typ == simdjson.TypeString {
v.Reason, _ = iter.String()
}
return nil
}
func (v ClosedEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["CLOSED",`)
@ -576,23 +382,6 @@ func (v *OKEnvelope) UnmarshalJSON(data []byte) error {
return nil
}
func (v *OKEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
if typ := iter.Advance(); typ == simdjson.TypeString {
v.EventID, _ = iter.String()
} else {
return fmt.Errorf("unexpected %s for OK id", typ)
}
if typ := iter.Advance(); typ == simdjson.TypeBool {
v.OK, _ = iter.Bool()
} else {
return fmt.Errorf("unexpected %s for OK status", typ)
}
if typ := iter.Advance(); typ == simdjson.TypeString {
v.Reason, _ = iter.String()
}
return nil
}
func (v OKEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["OK","`)
@ -635,21 +424,6 @@ func (v *AuthEnvelope) UnmarshalJSON(data []byte) error {
return nil
}
func (v *AuthEnvelope) UnmarshalSIMD(iter simdjson.Iter) error {
if typ := iter.Advance(); typ == simdjson.TypeString {
// we have a challenge
subID, err := iter.String()
if err != nil {
return err
}
v.Challenge = &subID
return nil
} else {
// we have an event
return v.Event.UnmarshalSIMD(&iter)
}
}
func (v AuthEnvelope) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{NoEscapeHTML: true}
w.RawString(`["AUTH",`)