batch_jaro_winkler 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f2ffa14f3a5763647191da3a1df8683a76d1a3919ee0b0dc3585a6827810801
-  data.tar.gz: ba85b0a2c0e9f729642701c9f5062d99ea90fa5f49a12ba0887d536709859d45
+  metadata.gz: 432282dad48464ef1b3bbbbdf7f58d23482a4995dd19a71e76d77053dff0d075
+  data.tar.gz: 5062b7c8d7854fa7966fde862b827d95d9fe7f14633102c2d785dc09a9a24cd9
 SHA512:
-  metadata.gz: 1334145d89c9a4f45900d728757fbc86ac5f6800dc2d09b7dc61d55a87fc6cc0fadb2490e7076e09dc22086ef09ead801f58965f6a46adc43714545d7040488b
-  data.tar.gz: 140a21c3203d148bcb5aa6f444114088f0a72eb44a655932855565945aacbf0916ded0a761e6eaee8a387e1e32473490866664e9b36dc9ad8f2c4b850fa36e7f
+  metadata.gz: fc6a7605d46daa03aff1e33bde2d9047af693ad10d2618635eea4f3aff8515b00ab82d999f7b49e4b4754748a11b450c37683a4746123e6378e9b1ebde127692
+  data.tar.gz: 594362d2c8d4ec96f6fe8efaa879b5a38b3de430dfba5639f61b154034d004fadf501f108164daadc0822988426e8f395df106a9f825ac1dafc81637a48d774f

data/ext/batch_jaro_winkler/ext/batch_jaro_winkler.c

@@ -326,13 +326,13 @@ static uint8_t	*build_exportable_model_for_thread(
 		if (store_original_candidates)
 		{
 			memcpy(
-				res_original_candidates + (candidates_char_decal * original_char_width),
+				(uint8_t*)res_original_candidates + (candidates_char_decal * original_char_width),
 				original_candidates[sorted_candidates[i_candidate].original_ind],
 				sorted_candidates[i_candidate].candidate_length * original_char_width
 			);
 		}
 		memcpy(
-			res_compressed_candidates + (candidates_char_decal * compressed_char_width),
+			(uint8_t*)res_compressed_candidates + (candidates_char_decal * compressed_char_width),
 			sorted_candidates[i_candidate].candidate,
 			sorted_candidates[i_candidate].candidate_length * compressed_char_width
 		);
@@ -415,8 +415,8 @@ static void		*build_exportable_model(
 {
 	uint32_t			i_thread;
 	uint32_t			i;
-	uint8_t				*model_per_thread[nb_runtime_threads];
-	uint32_t			model_size_per_thread[nb_runtime_threads];
+	uint8_t				**model_per_thread;
+	uint32_t			*model_size_per_thread;
 	uint8_t				*res_buffer;
 	uint8_t				*res_buffer_head;
 	void				**original_candidates_for_thread;
@@ -427,6 +427,9 @@ static void		*build_exportable_model(
 	uint32_t			nb_taken_candidates;
 	uint32_t			aligned_model_size;
 
+	model_per_thread = malloc(sizeof(uint8_t*) * nb_runtime_threads);
+	model_size_per_thread = malloc(sizeof(uint32_t) * nb_runtime_threads);
+
 	nb_taken_candidates = 0;
 	*res_model_size = 0;
 	for (i_thread = 0; i_thread < nb_runtime_threads; i_thread++)
@@ -445,6 +448,8 @@ static void		*build_exportable_model(
 		{
 			for (i = 0; i < i_thread; i++)
 				free(model_per_thread[i]);
+			free(model_per_thread);
+			free(model_size_per_thread);
 			return (NULL);
 		}
 		// align on next 4 byte boundary
@@ -459,6 +464,8 @@ static void		*build_exportable_model(
 	{
 		for (i_thread = 0; i_thread < nb_runtime_threads; i_thread++)
 			free(model_per_thread[i_thread]);
+		free(model_per_thread);
+		free(model_size_per_thread);
 		return (NULL);
 	}
 	*((uint32_t*)(res_buffer + sizeof(uint32_t) * 0)) = nb_runtime_threads;
@@ -478,6 +485,9 @@ static void		*build_exportable_model(
 		free(model_per_thread[i_thread]);
 	}
 
+	free(model_per_thread);
+	free(model_size_per_thread);
+
 	return (res_buffer);
 }
 
@@ -621,8 +631,8 @@ void	bjw_free_runtime_model(void *runtime_model)
 	uint32_t	char_width;
 	uint32_t	char_access_width;
 
-	char_width = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 2));
-	char_access_width = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 3));
+	char_width = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 2));
+	char_access_width = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 3));
 	
 	void (*free_function)(void*) = NULL;
 	if (char_width == 4 && char_access_width == 4)
@@ -720,18 +730,18 @@ bjw_result	*bjw_jaro_winkler_distance(void *runtime_model, void *input, uint32_t
 	uint32_t		results_decal;
 	t_thread_data	*threads_data;
 #if BJW_USE_THREADS
-# ifdef _WIN32
+# if defined(_WIN32) || defined(_WIN64)
 	HANDLE			*threads;
 # else
 	pthread_t		*threads;
 # endif
 #endif
 
-	nb_runtime_threads = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 0));
-	nb_candidates = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 1));
-	char_width = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 2));
-	char_access_width = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 3));
-	original_char_width = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 4));
+	nb_runtime_threads = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 0));
+	nb_candidates = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 1));
+	char_width = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 2));
+	char_access_width = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 3));
+	original_char_width = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 4));
 
 	// Characters after 256 won't be taken into consideration for score calculation anyway, and uint8_t won't be able to represent the indices.
 	if (char_access_width == 1 && input_length >= 256)
@@ -743,7 +753,7 @@ bjw_result	*bjw_jaro_winkler_distance(void *runtime_model, void *input, uint32_t
 		n_best_results = nb_candidates;
 
 #if BJW_USE_THREADS
-# ifdef _WIN32
+# if defined(_WIN32) || defined(_WIN64)
 	if (!(threads = malloc(sizeof(HANDLE) * nb_runtime_threads)))
 		return (NULL);
 # else
@@ -810,7 +820,7 @@ bjw_result	*bjw_jaro_winkler_distance(void *runtime_model, void *input, uint32_t
 		for (i_thread = 0; i_thread < nb_runtime_threads; i_thread++)
 		{
 			threads_data[i_thread] = (t_thread_data){
-				.runtime_models = runtime_model + sizeof(uint32_t) * 5,
+				.runtime_models = ((uint8_t*)runtime_model) + sizeof(uint32_t) * 5,
 				.i_thread = i_thread,
 				.original_char_width = original_char_width,
 				.input = input,
@@ -824,7 +834,7 @@ bjw_result	*bjw_jaro_winkler_distance(void *runtime_model, void *input, uint32_t
 			};
 
 #if BJW_USE_THREADS
-# ifdef _WIN32
+# if defined(_WIN32) || defined(_WIN64)
 			threads[i_thread] = CreateThread(NULL, 0, runtime_function, &(threads_data[i_thread]), 0, NULL);
 # else
 			pthread_create(&(threads[i_thread]), NULL, runtime_function, &(threads_data[i_thread]));
@@ -838,7 +848,7 @@ bjw_result	*bjw_jaro_winkler_distance(void *runtime_model, void *input, uint32_t
 		for (i_thread = 0; i_thread < nb_runtime_threads; i_thread++)
 		{
 #if BJW_USE_THREADS
-# ifdef _WIN32
+# if defined(_WIN32) || defined(_WIN64)
 			WaitForSingleObject(threads[i_thread], INFINITE);
 			CloseHandle(threads[i_thread]);
 # else

data/ext/batch_jaro_winkler/ext/batch_jaro_winkler_internal.h

@@ -35,7 +35,7 @@ SOFTWARE.
 # include <math.h>
 
 # if BJW_USE_THREADS
-#  ifdef _WIN32
+#  if defined(_WIN32) || defined(_WIN64)
 #   include <windows.h>
 #  else
 #   include <pthread.h>

data/ext/batch_jaro_winkler/ext/batch_jaro_winkler_runtime.h

@@ -26,6 +26,10 @@ SOFTWARE.
 #define BJW_SUFFIX_HANDLER(name, type1, type2) BJW_SUFFIX_PASTER(name, type1, type2)
 #define BJW_SUFFIX(name) BJW_SUFFIX_HANDLER(name, BJW_CHAR_TYPE, BJW_CHAR_ACCESS_TYPE)
 
+#if defined(_WIN32) || defined(_WIN64)
+	#define bzero(b,len) (memset((b), '\0', (len)), (void) 0)
+#endif
+
 // this represents the data needed for a candidate when finding matches
 typedef struct
 {
@@ -212,8 +216,8 @@ static void		BJW_SUFFIX(free_runtime_model)
 	uint32_t						i_thread;
 	uint32_t						nb_runtime_threads;
 
-	nb_runtime_threads = *((uint32_t*)(runtime_model + sizeof(uint32_t) * 0));
-	runtime_models = (BJW_SUFFIX(t_runtime_model)*)(runtime_model + sizeof(uint32_t) * 5);
+	nb_runtime_threads = *((uint32_t*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 0));
+	runtime_models = (BJW_SUFFIX(t_runtime_model)*)(((uint8_t*)runtime_model) + sizeof(uint32_t) * 5);
 	for (i_thread = 0; i_thread < nb_runtime_threads; i_thread++)
 		BJW_SUFFIX(free_runtime_model_for_thread)(&(runtime_models[i_thread]));
 	free(runtime_model);
@@ -230,12 +234,12 @@ static void		*BJW_SUFFIX(build_runtime_model)
 	res = malloc(sizeof(BJW_SUFFIX(t_runtime_model)) * nb_runtime_threads + sizeof(uint32_t) * 5);
 	if (!res)
 		return (NULL);
-	*((uint32_t*)(res + sizeof(uint32_t) * 0)) = nb_runtime_threads;
-	*((uint32_t*)(res + sizeof(uint32_t) * 1)) = nb_candidates;
-	*((uint32_t*)(res + sizeof(uint32_t) * 2)) = sizeof(BJW_CHAR_TYPE);
-	*((uint32_t*)(res + sizeof(uint32_t) * 3)) = sizeof(BJW_CHAR_ACCESS_TYPE);
-	*((uint32_t*)(res + sizeof(uint32_t) * 4)) = original_char_width;
-	runtime_models = res + sizeof(uint32_t) * 5;
+	*((uint32_t*)((uint8_t*)res + sizeof(uint32_t) * 0)) = nb_runtime_threads;
+	*((uint32_t*)((uint8_t*)res + sizeof(uint32_t) * 1)) = nb_candidates;
+	*((uint32_t*)((uint8_t*)res + sizeof(uint32_t) * 2)) = sizeof(BJW_CHAR_TYPE);
+	*((uint32_t*)((uint8_t*)res + sizeof(uint32_t) * 3)) = sizeof(BJW_CHAR_ACCESS_TYPE);
+	*((uint32_t*)((uint8_t*)res + sizeof(uint32_t) * 4)) = original_char_width;
+	runtime_models = (BJW_SUFFIX(t_runtime_model)*)((uint8_t*)res + sizeof(uint32_t) * 5);
 
 	for (i_thread = 0; i_thread < nb_runtime_threads; i_thread++)
 	{
@@ -426,7 +430,7 @@ static uint32_t		BJW_SUFFIX(jaro_winkler_distance_from_flags)
 		{
 			if (candidate_min_score <= 0.0f)
 			{
-				results[nb_results].candidate = runtime_model->original_candidates + original_char_width * candidate_decal;
+				results[nb_results].candidate = ((uint8_t*)(runtime_model->original_candidates)) + original_char_width * candidate_decal;
 				results[nb_results].score = 0.0f;
 				results[nb_results].candidate_length = candidate_data->candidate_length;
 				nb_results++;
@@ -458,7 +462,7 @@ static uint32_t		BJW_SUFFIX(jaro_winkler_distance_from_flags)
 		if (score < candidate_min_score)
 			continue ;
 
-		results[nb_results].candidate = runtime_model->original_candidates + original_char_width * candidate_decal;
+		results[nb_results].candidate = ((uint8_t*)(runtime_model->original_candidates)) + original_char_width * candidate_decal;
 		results[nb_results].score = score;
 		results[nb_results].candidate_length = candidate_data->candidate_length;
 		nb_results++;

data/ext/batch_jaro_winkler/ext/uthash.h

@@ -63,7 +63,7 @@ do {
 #endif
 
 /* a number of the hash function use uint32_t which isn't defined on Pre VS2010 */
-#if defined(_WIN32)
+#if defined(_WIN32) || defined(_WIN64)
 #if defined(_MSC_VER) && _MSC_VER >= 1600
 #include <stdint.h>
 #elif defined(__WATCOMC__) || defined(__MINGW32__) || defined(__CYGWIN__)

data/lib/batch_jaro_winkler/version.rb

@@ -1,3 +1,3 @@
 module BatchJaroWinkler
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: batch_jaro_winkler
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Dominik Bousquet
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-24 00:00:00.000000000 Z
+date: 2023-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.0
+        version: 1.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.0
+        version: 1.16.0
 description: This project gets its performance from the pre-calculation of an optimized
   model in advance of the actual runtime calculations. Supports any encoding.
 email: bousquet.dominik@gmail.com
@@ -62,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Fast batch jaro winkler distance implementation in C99.