Allow passing []string

[richiejp]

Operating System

• Windows
• macOS
• Linux
• FreeBSD
• Android
• iOS

What feature would you like to be added?

I want to be able to pass []string from Go and have it converted to *char[] or **char with the last element being NULL.

Why is this needed?

So that we can pass a variable length list of strings from Go without having to serialize them.

In the LocalAI stabeldiffusion backend we pass a list of option strings which are key-values. These are then used to populate a large struct. Supporting structs on all platforms could be an alternative in this case, but perhaps a more difficult one because of padding.

In LocalAI I converted to the oo []string array like so, where CString is copied from Purego:

 var keepAlive []any
 options := make([]uintptr, len(oo), len(oo)+1)
 for i, op := range oo {
   bytep := CString(op)
   options[i] = uintptr(unsafe.Pointer(bytep))
   keepAlive = append(keepAlive, bytep)
 }

 ...

 ret := LoadModel(modelFile, modelPathC, options, opts.Threads, diffusionModel)
 if ret != 0 {
   return fmt.Errorf("could not load model")
 }

 runtime.KeepAlive(keepAlive)

This appears to work and is not complicated, but was difficult to figure out having never used unsafe pointers in Go before.

[TotallyGamerJet]

I don't think that's a good idea. A []string may be a null terminated **char but it also may not be null-terminated as another parameter passes the length. Plus that is an extremely expensive operation to copy all the strings and seems a little against Go philosophy to just do all those allocations for the user.

Side note:

Your code is currently breaking a package unsafe rule:

A uintptr is an integer, not a reference. Converting a Pointer to a uintptr creates an integer value with no pointer semantics. Even if a uintptr holds the address of some object, the garbage collector will not update that uintptr's value if the object moves, nor will that uintptr keep the object from being reclaimed.

Here's the corrected code:

 var keepAlive []any
 options := make([]*byte, len(oo), len(oo)+1)
 for i, op := range oo {
   options[i] = CString(op)
   keepAlive = append(keepAlive, bytep)
 }

 ...

 ret := LoadModel(modelFile, modelPathC, options, opts.Threads, diffusionModel)
 if ret != 0 {
   return fmt.Errorf("could not load model")
 }

 runtime.KeepAlive(keepAlive)

[richiejp]

I don't think that's a good idea. A []string may be a null terminated **char but it also may not be null-terminated as another parameter passes the length. Plus that is an extremely expensive operation to copy all the strings and seems a little against Go philosophy to just do all those allocations for the user.

In that case, instead of just doing the conversion to a null terminated array, we could include a helper function that does it and have NULL termination as a parameter?

Here's the corrected code: ...

That's what I tried first, but you can't pass *byte, the result is not a valid pointer. It appears to result in an array of internal Go references/offsets. It needs to be converted to uintptr via unsafe.Pointer or similar. The call to runtime.KeepAlive is supposed to prevent GC, although I don't know if it would prevent the memory being moved. If the memory can be moved then the way Purego already passes strings is broken.