Try converting SD to purego

Author: richiejp

backend/go/stablediffusion-ggml/Makefile

@@ -128,6 +128,15 @@ else
 	$(CXX) $(CXXFLAGS) gosd.cpp -o gosd.o -c
 endif
 
+gosd.so: sources/stablediffusion-ggml.cpp build/libstable-diffusion.a
+ifneq (,$(findstring sycl,$(BUILD_TYPE)))
+	+bash -c "source $(ONEAPI_VARS); \
+	$(CXX) $(CXXFLAGS) gosd.cpp -o gosd.so -shared -lggmlall -lstable-diffusion -L./ -L./build"
+else
+	$(CXX) $(CXXFLAGS) gosd.cpp -o gosd.so -shared -lggmlall -lstable-diffusion -L./ -L./build
+endif
+
+
 ## stablediffusion (ggml)
 sources/stablediffusion-ggml.cpp:
 	git clone --recursive $(STABLEDIFFUSION_GGML_REPO) sources/stablediffusion-ggml.cpp && \
@@ -144,6 +153,9 @@ stablediffusion-ggml: libsd.a
 	CC="$(CC)" CXX="$(CXX)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" \
 	$(GOCMD) build -ldflags "$(LD_FLAGS)" -tags "$(GO_TAGS)" -o stablediffusion-ggml ./
 
+stablediffusion-ggml-pure: main.go gosd.go gosd.so
+	CGO_ENABLED=0 $(GOCMD) build -tags "$(GO_TAGS)" -o stablediffusion-ggml-pure ./
+
 package:
 	bash package.sh
 

backend/go/stablediffusion-ggml/gosd.cpp

@@ -1,3 +1,4 @@
+#include <cstdint>
 #define GGML_MAX_NAME 128
 
 #include <stdio.h>
@@ -226,7 +227,7 @@ int load_model(char *model, char *model_path, char* options[], int threads, int
     return 0;
 }
 
-int gen_image(char *text, char *negativeText, int width, int height, int steps, int seed , char *dst, float cfg_scale, char *src_image, float strength, char *mask_image, char **ref_images, int ref_images_count) {
+int gen_image(char *text, char *negativeText, int width, int height, int steps, int64_t seed, char *dst, float cfg_scale, char *src_image, float strength, char *mask_image, char **ref_images, int ref_images_count) {
 
     sd_image_t* results;
 
@@ -252,14 +253,14 @@ int gen_image(char *text, char *negativeText, int width, int height, int steps,
     // Handle input image for img2img
     bool has_input_image = (src_image != NULL && strlen(src_image) > 0);
     bool has_mask_image = (mask_image != NULL && strlen(mask_image) > 0);
-    
+
     uint8_t* input_image_buffer = NULL;
     uint8_t* mask_image_buffer = NULL;
     std::vector<uint8_t> default_mask_image_vec;
-    
+
     if (has_input_image) {
         fprintf(stderr, "Loading input image: %s\n", src_image);
-        
+
         int c = 0;
         int img_width = 0;
         int img_height = 0;
@@ -273,29 +274,29 @@ int gen_image(char *text, char *negativeText, int width, int height, int steps,
             free(input_image_buffer);
             return 1;
         }
-        
+
         // Resize input image if dimensions don't match
         if (img_width != width || img_height != height) {
             fprintf(stderr, "Resizing input image from %dx%d to %dx%d\n", img_width, img_height, width, height);
-            
+
             uint8_t* resized_image_buffer = (uint8_t*)malloc(height * width * 3);
             if (resized_image_buffer == NULL) {
                 fprintf(stderr, "Failed to allocate memory for resized image\n");
                 free(input_image_buffer);
                 return 1;
             }
-            
+
             stbir_resize(input_image_buffer, img_width, img_height, 0,
                          resized_image_buffer, width, height, 0, STBIR_TYPE_UINT8,
                          3, STBIR_ALPHA_CHANNEL_NONE, 0,
                          STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP,
                          STBIR_FILTER_BOX, STBIR_FILTER_BOX,
                          STBIR_COLORSPACE_SRGB, nullptr);
-            
+
             free(input_image_buffer);
             input_image_buffer = resized_image_buffer;
         }
-        
+
         p.init_image = {(uint32_t)width, (uint32_t)height, 3, input_image_buffer};
         p.strength = strength;
         fprintf(stderr, "Using img2img with strength: %.2f\n", strength);
@@ -304,11 +305,11 @@ int gen_image(char *text, char *negativeText, int width, int height, int steps,
         p.init_image = {(uint32_t)width, (uint32_t)height, 3, NULL};
         p.strength = 0.0f;
     }
-    
+
     // Handle mask image for inpainting
     if (has_mask_image) {
         fprintf(stderr, "Loading mask image: %s\n", mask_image);
-        
+
         int c = 0;
         int mask_width = 0;
         int mask_height = 0;
@@ -318,30 +319,30 @@ int gen_image(char *text, char *negativeText, int width, int height, int steps,
             if (input_image_buffer) free(input_image_buffer);
             return 1;
         }
-        
+
         // Resize mask if dimensions don't match
         if (mask_width != width || mask_height != height) {
             fprintf(stderr, "Resizing mask image from %dx%d to %dx%d\n", mask_width, mask_height, width, height);
-            
+
             uint8_t* resized_mask_buffer = (uint8_t*)malloc(height * width);
             if (resized_mask_buffer == NULL) {
                 fprintf(stderr, "Failed to allocate memory for resized mask\n");
                 free(mask_image_buffer);
                 if (input_image_buffer) free(input_image_buffer);
                 return 1;
             }
-            
+
             stbir_resize(mask_image_buffer, mask_width, mask_height, 0,
                          resized_mask_buffer, width, height, 0, STBIR_TYPE_UINT8,
                          1, STBIR_ALPHA_CHANNEL_NONE, 0,
                          STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP,
                          STBIR_FILTER_BOX, STBIR_FILTER_BOX,
                          STBIR_COLORSPACE_SRGB, nullptr);
-            
+
             free(mask_image_buffer);
             mask_image_buffer = resized_mask_buffer;
         }
-        
+
         p.mask_image = {(uint32_t)width, (uint32_t)height, 1, mask_image_buffer};
         fprintf(stderr, "Using inpainting with mask\n");
     } else {
@@ -353,17 +354,17 @@ int gen_image(char *text, char *negativeText, int width, int height, int steps,
     // Handle reference images
     std::vector<sd_image_t> ref_images_vec;
     std::vector<uint8_t*> ref_image_buffers;
-    
+
     if (ref_images_count > 0 && ref_images != NULL) {
         fprintf(stderr, "Loading %d reference images\n", ref_images_count);
-        
+
         for (int i = 0; i < ref_images_count; i++) {
             if (ref_images[i] == NULL || strlen(ref_images[i]) == 0) {
                 continue;
             }
-            
+
             fprintf(stderr, "Loading reference image %d: %s\n", i + 1, ref_images[i]);
-            
+
             int c = 0;
             int ref_width = 0;
             int ref_height = 0;
@@ -377,33 +378,33 @@ int gen_image(char *text, char *negativeText, int width, int height, int steps,
                 free(ref_image_buffer);
                 continue;
             }
-            
+
             // Resize reference image if dimensions don't match
             if (ref_width != width || ref_height != height) {
                 fprintf(stderr, "Resizing reference image from %dx%d to %dx%d\n", ref_width, ref_height, width, height);
-                
+
                 uint8_t* resized_ref_buffer = (uint8_t*)malloc(height * width * 3);
                 if (resized_ref_buffer == NULL) {
                     fprintf(stderr, "Failed to allocate memory for resized reference image\n");
                     free(ref_image_buffer);
                     continue;
                 }
-                
+
                 stbir_resize(ref_image_buffer, ref_width, ref_height, 0,
                              resized_ref_buffer, width, height, 0, STBIR_TYPE_UINT8,
                              3, STBIR_ALPHA_CHANNEL_NONE, 0,
                              STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP,
                              STBIR_FILTER_BOX, STBIR_FILTER_BOX,
                              STBIR_COLORSPACE_SRGB, nullptr);
-                
+
                 free(ref_image_buffer);
                 ref_image_buffer = resized_ref_buffer;
             }
-            
+
             ref_image_buffers.push_back(ref_image_buffer);
             ref_images_vec.push_back({(uint32_t)width, (uint32_t)height, 3, ref_image_buffer});
         }
-        
+
         if (!ref_images_vec.empty()) {
             p.ref_images = ref_images_vec.data();
             p.ref_images_count = ref_images_vec.size();

backend/go/stablediffusion-ggml/gosd.go

@@ -1,11 +1,5 @@
 package main
 
-// #cgo CXXFLAGS: -I${SRCDIR}/sources/stablediffusion-ggml.cpp/thirdparty -I${SRCDIR}/sources/stablediffusion-ggml.cpp -I${SRCDIR}/sources/stablediffusion-ggml.cpp/ggml/include
-// #cgo LDFLAGS: -L${SRCDIR}/ -lsd -lstdc++ -lm -lggmlall -lgomp
-// #include <gosd.h>
-// #include <stdlib.h>
-import "C"
-
 import (
 	"fmt"
 	"os"
@@ -25,25 +19,19 @@ type SDGGML struct {
 	cfgScale     float32
 }
 
+var (
+	LoadModel func(model, model_apth string, options []string, threads int32, diff int) int
+	GenImage func(text, negativeText string, width, height, steps int, seed int64, dst string, cfgScale float32, srcImage string, strength float32, maskImage string, refImages []string, refImagesCount int) int
+)
+
 func (sd *SDGGML) Load(opts *pb.ModelOptions) error {
 
 	sd.threads = int(opts.Threads)
 
 	modelPath := opts.ModelPath
 
-	modelFile := C.CString(opts.ModelFile)
-	defer C.free(unsafe.Pointer(modelFile))
-
-	modelPathC := C.CString(modelPath)
-	defer C.free(unsafe.Pointer(modelPathC))
-
-	var options **C.char
-	// prepare the options array to pass to C
-
-	size := C.size_t(unsafe.Sizeof((*C.char)(nil)))
-	length := C.size_t(len(opts.Options))
-	options = (**C.char)(C.malloc((length + 1) * size))
-	view := (*[1 << 30]*C.char)(unsafe.Pointer(options))[0 : len(opts.Options)+1 : len(opts.Options)+1]
+	modelFile := opts.ModelFile
+	modelPathC := modelPath
 
 	var diffusionModel int
 
@@ -68,14 +56,12 @@ func (sd *SDGGML) Load(opts *pb.ModelOptions) error {
 
 	fmt.Fprintf(os.Stderr, "Options: %+v\n", oo)
 
-	for i, x := range oo {
-		view[i] = C.CString(x)
-	}
-	view[len(oo)] = nil
+	options := make([]string, len(oo), len(oo) + 1)
+	*(*uintptr)(unsafe.Add(unsafe.Pointer(&options), uintptr(len(oo)))) = 0
 
 	sd.cfgScale = opts.CFGScale
 
-	ret := C.load_model(modelFile, modelPathC, options, C.int(opts.Threads), C.int(diffusionModel))
+	ret := LoadModel(modelFile, modelPathC, options, opts.Threads, diffusionModel)
 	if ret != 0 {
 		return fmt.Errorf("could not load model")
 	}
@@ -84,65 +70,33 @@ func (sd *SDGGML) Load(opts *pb.ModelOptions) error {
 }
 
 func (sd *SDGGML) GenerateImage(opts *pb.GenerateImageRequest) error {
-	t := C.CString(opts.PositivePrompt)
-	defer C.free(unsafe.Pointer(t))
+	t := opts.PositivePrompt
+	dst := opts.Dst
+	negative := opts.NegativePrompt
+	srcImage := opts.Src
 
-	dst := C.CString(opts.Dst)
-	defer C.free(unsafe.Pointer(dst))
-
-	negative := C.CString(opts.NegativePrompt)
-	defer C.free(unsafe.Pointer(negative))
-
-	// Handle source image path
-	var srcImage *C.char
-	if opts.Src != "" {
-		srcImage = C.CString(opts.Src)
-		defer C.free(unsafe.Pointer(srcImage))
-	}
-
-	// Handle mask image path
-	var maskImage *C.char
+	var maskImage string
 	if opts.EnableParameters != "" {
-		// Parse EnableParameters for mask path if provided
-		// This is a simple approach - in a real implementation you might want to parse JSON
 		if strings.Contains(opts.EnableParameters, "mask:") {
 			parts := strings.Split(opts.EnableParameters, "mask:")
 			if len(parts) > 1 {
 				maskPath := strings.TrimSpace(parts[1])
 				if maskPath != "" {
-					maskImage = C.CString(maskPath)
-					defer C.free(unsafe.Pointer(maskImage))
+					maskImage = maskPath
 				}
 			}
 		}
 	}
 
-	// Handle reference images
-	var refImages **C.char
-	var refImagesCount C.int
-	if len(opts.RefImages) > 0 {
-		refImagesCount = C.int(len(opts.RefImages))
-		// Allocate array of C strings
-		size := C.size_t(unsafe.Sizeof((*C.char)(nil)))
-		refImages = (**C.char)(C.malloc((C.size_t(len(opts.RefImages)) + 1) * size))
-		view := (*[1 << 30]*C.char)(unsafe.Pointer(refImages))[0 : len(opts.RefImages)+1 : len(opts.RefImages)+1]
-
-		for i, refImagePath := range opts.RefImages {
-			view[i] = C.CString(refImagePath)
-			defer C.free(unsafe.Pointer(view[i]))
-		}
-		view[len(opts.RefImages)] = nil
-	}
+	refImagesCount := len(opts.RefImages)
+	refImages := make([]string, refImagesCount, refImagesCount + 1)
+	copy(refImages, opts.RefImages)
+	*(*uintptr)(unsafe.Add(unsafe.Pointer(&refImages), refImagesCount)) = 0
 
 	// Default strength for img2img (0.75 is a good default)
-	strength := C.float(0.75)
-	if opts.Src != "" {
-		// If we have a source image, use img2img mode
-		// You could also parse strength from EnableParameters if needed
-		strength = C.float(0.75)
-	}
+	strength := float32(0.75)
 
-	ret := C.gen_image(t, negative, C.int(opts.Width), C.int(opts.Height), C.int(opts.Step), C.int(opts.Seed), dst, C.float(sd.cfgScale), srcImage, strength, maskImage, refImages, refImagesCount)
+	ret := GenImage(t, negative, int(opts.Width), int(opts.Height), int(opts.Step), int64(opts.Seed), dst, sd.cfgScale, srcImage, strength, maskImage, refImages, refImagesCount)
 	if ret != 0 {
 		return fmt.Errorf("inference failed")
 	}

backend/go/stablediffusion-ggml/main.go

@@ -3,15 +3,35 @@ package main
 // Note: this is started internally by LocalAI and a server is allocated for each model
 import (
 	"flag"
+	"fmt"
+	"runtime"
 
+	"github.com/ebitengine/purego"
 	grpc "github.com/mudler/LocalAI/pkg/grpc"
 )
 
 var (
 	addr = flag.String("addr", "localhost:50051", "the address to connect to")
 )
 
+func getLibrary() string {
+	switch runtime.GOOS {
+	case "linux":
+		return "./gosd.so"
+	default:
+		panic(fmt.Errorf("GOOS=%s is not supported", runtime.GOOS))
+	}
+}
+
 func main() {
+	gosd, err := purego.Dlopen(getLibrary(), purego.RTLD_NOW|purego.RTLD_GLOBAL)
+	if err != nil {
+		panic(err)
+	}
+
+	purego.RegisterLibFunc(&LoadModel, gosd, "load_model")
+	purego.RegisterLibFunc(&GenImage, gosd, "gen_image")
+
 	flag.Parse()
 
 	if err := grpc.StartServer(*addr, &SDGGML{}); err != nil {

go.mod

@@ -12,6 +12,7 @@ require (
 	github.com/chasefleming/elem-go v0.26.0
 	github.com/containerd/containerd v1.7.19
 	github.com/dave-gray101/v2keyauth v0.0.0-20240624150259-c45d584d25e2
+	github.com/ebitengine/purego v0.8.4
 	github.com/fsnotify/fsnotify v1.7.0
 	github.com/ggerganov/whisper.cpp/bindings/go v0.0.0-20240626202019-c118733a29ad
 	github.com/go-audio/wav v1.1.0

go.sum

@@ -134,6 +134,8 @@ github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdf
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
+github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/elastic/gosigar v0.12.0/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
 github.com/elastic/gosigar v0.14.3 h1:xwkKwPia+hSfg9GqrCUKYdId102m9qTJIIr7egmK/uo=
 github.com/elastic/gosigar v0.14.3/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=