Created
July 15, 2020 05:41
-
-
Save carlgieringer/814b45b8525bf71529a26bf88cfc4f0a to your computer and use it in GitHub Desktop.
Output from faiss make
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c AutoTune.cpp -o AutoTune.o | |
| In file included from AutoTune.cpp:31: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| AutoTune.cpp:68:20: warning: comparison of integers of different signs: 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| (gt_I.size() == gt_nnn * nq && gt_nnn >= 1 && nnn >= R), | |
| ~~~~~~~~~~~ ^ ~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| AutoTune.cpp:92:20: warning: comparison of integers of different signs: 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| (gt_I.size() == gt_nnn * nq && gt_nnn >= R && nnn >= R), | |
| ~~~~~~~~~~~ ^ ~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| AutoTune.cpp:144:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (i = 0; i < a.size(); i++) { | |
| ~ ^ ~~~~~~~~ | |
| AutoTune.cpp:147:19: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| assert (i < a.size()); | |
| ~ ^ ~~~~~~~~ | |
| /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/assert.h:93:25: note: expanded from macro 'assert' | |
| (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0) | |
| ^ | |
| AutoTune.cpp:174:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < other.all_pts.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:207:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < all_pts.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| AutoTune.cpp:223:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < optimal_pts.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:251:17: warning: format specifies type 'long' but the argument has type 'int64_t' (aka 'long long') [-Wformat] | |
| op.cno, op.key.c_str(), op.perf, op.t, star); | |
| ^~~~~~ | |
| AutoTune.cpp:239:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < pts.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| AutoTune.cpp:243:31: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < optimal_pts.size(); j++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:284:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::ParameterRange, std::__1::allocator<faiss::ParameterRange> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < parameter_ranges.size(); i++) | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:293:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::ParameterRange, std::__1::allocator<faiss::ParameterRange> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < parameter_ranges.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:307:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::ParameterRange, std::__1::allocator<faiss::ParameterRange> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < parameter_ranges.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:329:27: warning: comparison of integers of different signs: 'int' and 'unsigned long' [-Wsign-compare] | |
| for (int i = 2; i <= pq.code_size * 8 / 2; i+= 2) | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:427:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::ParameterRange, std::__1::allocator<faiss::ParameterRange> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < parameter_ranges.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:571:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::ParameterRange, std::__1::allocator<faiss::ParameterRange> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < parameter_ranges.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:575:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<double, std::__1::allocator<double> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < pr.values.size(); j++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:604:32: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const faiss::AutoTuneCriterion::idx_t' (aka 'const long long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (nq == crit.nq, | |
| ~~ ^ ~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| AutoTune.cpp:634:15: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (n_exp > n_comb) n_exp = n_comb; | |
| ~~~~~ ^ ~~~~~~ | |
| AutoTune.cpp:642:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 2; i < perm.size(); i++) perm[i] ++; | |
| ~ ^ ~~~~~~~~~~~ | |
| AutoTune.cpp:645:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t xp = 0; xp < n_exp; xp++) { | |
| ~~ ^ ~~~~~ | |
| AutoTune.cpp:655:31: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::OperatingPoint, std::__1::allocator<faiss::OperatingPoint> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ops->all_pts.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~ | |
| In file included from AutoTune.cpp:31: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:123:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| AutoTune.cpp:478:13: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::runOnIndex' requested here | |
| ix->runOnIndex(fn); | |
| ^ | |
| In file included from AutoTune.cpp:31: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:135:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:179:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::future<bool>, std::__1::allocator<std::__1::future<bool> > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < v.size(); ++i) { | |
| ~ ^ ~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:129:5: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::waitAndHandleFutures' requested here | |
| waitAndHandleFutures(v); | |
| ^ | |
| AutoTune.cpp:478:13: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::runOnIndex' requested here | |
| ix->runOnIndex(fn); | |
| ^ | |
| 27 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c Clustering.cpp -o Clustering.o | |
| Clustering.cpp:101:55: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| clus.k * clus.max_points_per_centroid, nx); | |
| ^~ | |
| Clustering.cpp:163:35: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'unsigned long' [-Wsign-compare] | |
| assert (ci >= 0 && ci < k + k_frozen); | |
| ~~ ^ ~~~~~~~~~~~~ | |
| /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/assert.h:93:25: note: expanded from macro 'assert' | |
| (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0) | |
| ^ | |
| Clustering.cpp:165:20: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (ci >= c0 && ci < c1) { | |
| ~~ ^ ~~ | |
| Clustering.cpp:165:32: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (ci >= c0 && ci < c1) { | |
| ~~ ^ ~~ | |
| Clustering.cpp:273:54: warning: format specifies type 'long' but the argument has type 'faiss::Clustering::idx_t' (aka 'long long') [-Wformat] | |
| "as large as number of clusters (%ld)", nx, k); | |
| ^~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| Clustering.cpp:273:54: warning: format specifies type 'long' but the argument has type 'faiss::Clustering::idx_t' (aka 'long long') [-Wformat] | |
| "as large as number of clusters (%ld)", nx, k); | |
| ^~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| Clustering.cpp:291:37: warning: 'finite' is deprecated: first deprecated in macOS 10.9 - Use `isfinite((double)x)` instead. [-Wdeprecated-declarations] | |
| FAISS_THROW_IF_NOT_MSG (finite (x[i]), | |
| ^ | |
| /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/math.h:749:12: note: 'finite' has been explicitly marked deprecated here | |
| extern int finite(double) | |
| ^ | |
| Clustering.cpp:312:18: warning: format specifies type 'long' but the argument has type 'faiss::Clustering::idx_t' (aka 'long long') [-Wformat] | |
| nx, k, idx_t(k) * min_points_per_centroid); | |
| ^~ | |
| Clustering.cpp:312:25: warning: format specifies type 'long' but the argument has type 'long long' [-Wformat] | |
| nx, k, idx_t(k) * min_points_per_centroid); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Clustering.cpp:319:48: warning: format specifies type 'long' but the argument has type 'faiss::Clustering::idx_t' (aka 'long long') [-Wformat] | |
| "clusters, just copying\n", nx); | |
| ^~ | |
| Clustering.cpp:271:32: warning: comparison of integers of different signs: 'faiss::Clustering::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_FMT (nx >= k, | |
| ~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| Clustering.cpp:275:49: warning: comparison of integers of different signs: 'const int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_FMT ((!codec || codec->d == d), | |
| ~~~~~~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| Clustering.cpp:279:37: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_FMT (index.d == d, | |
| ~~~~~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| Clustering.cpp:301:12: warning: comparison of integers of different signs: 'faiss::Clustering::idx_t' (aka 'long long') and 'unsigned long' [-Wsign-compare] | |
| if (nx > k * max_points_per_centroid) { | |
| ~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Clustering.cpp:308:19: warning: comparison of integers of different signs: 'faiss::Clustering::idx_t' (aka 'long long') and 'unsigned long' [-Wsign-compare] | |
| } else if (nx < k * min_points_per_centroid) { | |
| ~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| Clustering.cpp:315:12: warning: comparison of integers of different signs: 'faiss::Clustering::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (nx == k) { | |
| ~~ ^ ~ | |
| Clustering.cpp:394:47: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = n_input_centroids; i < k ; i++) { | |
| ~ ^ ~ | |
| Clustering.cpp:398:47: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = n_input_centroids; i < k ; i++) { | |
| ~ ^ ~ | |
| Clustering.cpp:429:40: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Clustering::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i0 = 0; i0 < nx; i0 += decode_block_size) { | |
| ~~ ^ ~~ | |
| Clustering.cpp:431:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Clustering::idx_t' (aka 'long long') [-Wsign-compare] | |
| if (i1 > nx) { i1 = nx; } | |
| ~~ ^ ~~ | |
| 20 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c DirectMap.cpp -o DirectMap.o | |
| DirectMap.cpp:50:36: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (long ofs = 0; ofs < list_size; ofs++) { | |
| ~~~ ^ ~~~~~~~~~ | |
| DirectMap.cpp:52:57: warning: comparison of integers of different signs: 'faiss::InvertedLists::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| 0 <= idlist [ofs] && idlist[ofs] < ntotal, | |
| ~~~~~~~~~~~ ^ ~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| DirectMap.cpp:57:36: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (long ofs = 0; ofs < list_size; ofs++) { | |
| ~~~ ^ ~~~~~~~~~ | |
| DirectMap.cpp:75:30: warning: comparison of integers of different signs: 'faiss::DirectMap::idx_t' (aka 'long long') and 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| key >= 0 && key < array.size(), "invalid key" | |
| ~~~ ^ ~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| DirectMap.cpp:96:20: warning: comparison of integers of different signs: 'faiss::DirectMap::idx_t' (aka 'long long') and 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| assert (id == array.size()); | |
| ~~ ^ ~~~~~~~~~~~~ | |
| /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/assert.h:93:25: note: expanded from macro 'assert' | |
| (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0) | |
| ^ | |
| DirectMap.cpp:145:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| DirectMap.cpp:168:29: warning: comparison of integers of different signs: 'faiss::DirectMap::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| DirectMap.cpp:187:29: warning: comparison of integers of different signs: 'faiss::DirectMap::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| DirectMap.cpp:201:29: warning: comparison of integers of different signs: 'faiss::DirectMap::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < sela->n; i++) { | |
| ~ ^ ~~~~~~~ | |
| DirectMap.cpp:209:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::DirectMap::idx_t' (aka 'long long') [-Wsign-compare] | |
| if (offset < last) { | |
| ~~~~~~ ^ ~~~~ | |
| DirectMap.cpp:239:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| DirectMap.cpp:241:47: warning: comparison of integers of different signs: 'faiss::DirectMap::idx_t' (aka 'long long') and 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (0 <= id && id < array.size(), | |
| ~~ ^ ~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| DirectMap.cpp:248:21: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'unsigned long' [-Wsign-compare] | |
| if (ofs != l - 1) { // move l - 1 to ofs | |
| ~~~ ^ ~~~~~ | |
| 13 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IVFlib.cpp -o IVFlib.o | |
| In file included from IVFlib.cpp:16: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| IVFlib.cpp:36:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::VectorTransform *, std::__1::allocator<faiss::VectorTransform *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < pt0->chain.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~ | |
| IVFlib.cpp:225:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| IVFlib.cpp:239:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| IVFlib.cpp:247:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| IVFlib.cpp:275:51: warning: comparison of integers of different signs: 'long' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (0 <= i0 && i0 <= i1 && i1 <= ivf->nlist); | |
| ~~ ^ ~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IVFlib.cpp:296:51: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (0 <= i0 && i0 <= i1 && i1 <= ivf->nlist); | |
| ~~ ^ ~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IVFlib.cpp:300:36: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (src->nlist == i1 - i0 && | |
| ~~~~~~~~~~ ^ ~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IVFlib.cpp:344:29: warning: comparison of integers of different signs: 'faiss::ivflib::idx_t' (aka 'long long') and 'unsigned long long' [-Wsign-compare] | |
| for (idx_t i = 0; i < n * params->nprobe; i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~ | |
| 10 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c Index.cpp -o Index.o | |
| Index.cpp:91:24: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t i = 0; i < d; i++) { | |
| ~ ^ ~ | |
| 1 warning generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c Index2Layer.cpp -o Index2Layer.o | |
| Index2Layer.cpp:81:17: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| n, d); | |
| ^ | |
| Index2Layer.cpp:108:32: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| pq.M, pq.ksub, n, d); | |
| ^ | |
| Index2Layer.cpp:123:24: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^~ | |
| Index2Layer.cpp:123:28: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^~ | |
| Index2Layer.cpp:123:32: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^ | |
| Index2Layer.cpp:419:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| Index2Layer.cpp:425:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| 7 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexBinary.cpp -o IndexBinary.o | |
| IndexBinary.cpp:73:65: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| printf("Index: %s -> %ld elements\n", typeid (*this).name(), ntotal); | |
| ~~~ ^~~~~~ | |
| %lld | |
| 1 warning generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexBinaryFlat.cpp -o IndexBinaryFlat.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexBinaryFromFloat.cpp -o IndexBinaryFromFloat.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexBinaryHNSW.cpp -o IndexBinaryHNSW.o | |
| IndexBinaryHNSW.cpp:67:20: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < ntotal; i++) { | |
| ~ ^ ~~~~~~ | |
| IndexBinaryHNSW.cpp:78:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexBinaryHNSW.cpp:81:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| while (pt_level >= hist.size()) { | |
| ~~~~~~~~ ^ ~~~~~~~~~~~ | |
| IndexBinaryHNSW.cpp:89:23: warning: comparison of integers of different signs: 'int' and 'unsigned long' [-Wsign-compare] | |
| for (int i = 0; i < hist.size() - 1; i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~ | |
| IndexBinaryHNSW.cpp:94:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexBinaryHNSW.cpp:150:20: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < ntotal; i++) | |
| ~ ^ ~~~~~~ | |
| IndexBinaryHNSW.cpp:234:40: warning: comparison of integers of different signs: 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| hnsw.levels.size() == ntotal); | |
| ~~~~~~~~~~~~~~~~~~ ^ ~~~~~~ | |
| 7 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexBinaryHash.cpp -o IndexBinaryHash.o | |
| IndexBinaryHash.cpp:225:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { // loop queries | |
| ~ ^ ~ | |
| IndexBinaryHash.cpp:249:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexBinaryHash.cpp:275:26: warning: format specifies type 'long' but the argument has type 'long long' [-Wformat] | |
| printf("%ld: [", it->first); | |
| ~~~ ^~~~~~~~~ | |
| %lld | |
| IndexBinaryHash.cpp:278:28: warning: format specifies type 'long' but the argument has type 'long long' [-Wformat] | |
| printf("%ld ", 0 + x); | |
| ~~~ ^~~~~ | |
| %lld | |
| IndexBinaryHash.cpp:359:33: warning: unused variable 'n0' [-Wunused-variable] | |
| size_t nlist = 0, ndis = 0, n0 = 0; | |
| ^ | |
| IndexBinaryHash.cpp:359:12: warning: unused variable 'nlist' [-Wunused-variable] | |
| size_t nlist = 0, ndis = 0, n0 = 0; | |
| ^ | |
| IndexBinaryHash.cpp:359:23: warning: unused variable 'ndis' [-Wunused-variable] | |
| size_t nlist = 0, ndis = 0, n0 = 0; | |
| ^ | |
| IndexBinaryHash.cpp:440:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { // loop queries | |
| ~ ^ ~ | |
| IndexBinaryHash.cpp:464:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| 9 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexBinaryIVF.cpp -o IndexBinaryIVF.o | |
| IndexBinaryIVF.cpp:40:25: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (d == quantizer->d); | |
| ~ ^ ~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IndexBinaryIVF.cpp:41:60: warning: comparison of integers of different signs: 'faiss::IndexBinary::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| is_trained = quantizer->is_trained && (quantizer->ntotal == nlist); | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~ | |
| IndexBinaryIVF.cpp:101:19: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| n_add, n); | |
| ^ | |
| IndexBinaryIVF.cpp:84:24: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexBinaryIVF.cpp:146:35: warning: comparison of integers of different signs: 'faiss::IndexBinary::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (idx_t list_no = 0; list_no < nlist; list_no++) { | |
| ~~~~~~~ ^ ~~~~~ | |
| IndexBinaryIVF.cpp:150:35: warning: comparison of integers of different signs: 'faiss::IndexBinary::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t offset = 0; offset < list_size; offset++) { | |
| ~~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:225:60: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| printf("Training quantizer on %ld vectors in %dD\n", n, d); | |
| ~~~ ^ | |
| %lld | |
| IndexBinaryIVF.cpp:219:51: warning: comparison of integers of different signs: 'faiss::IndexBinary::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (quantizer->is_trained && (quantizer->ntotal == nlist)) { | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~ | |
| IndexBinaryIVF.cpp:272:36: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| il->code_size == code_size); | |
| ~~~~~~~~~~~~~ ^ ~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IndexBinaryIVF.cpp:338:16: warning: unused variable 'nup' [-Wunused-variable] | |
| size_t nup = 0; | |
| ^ | |
| IndexBinaryIVF.cpp:355:62: warning: unused parameter 'code_size' [-Wunused-parameter] | |
| BinaryInvertedListScanner *select_IVFBinaryScannerL2 (size_t code_size) { | |
| ^ | |
| IndexBinaryIVF.cpp:411:22: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:411:22: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:402:36: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:433:40: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:593:13: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer4>' requested here | |
| case 4: HC(HammingComputer4); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:594:13: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer8>' requested here | |
| case 8: HC(HammingComputer8); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:595:14: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer16>' requested here | |
| case 16: HC(HammingComputer16); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:596:14: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer20>' requested here | |
| case 20: HC(HammingComputer20); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:597:14: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer32>' requested here | |
| case 32: HC(HammingComputer32); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:598:14: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer64>' requested here | |
| case 64: HC(HammingComputer64); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:601:13: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM8>' requested here | |
| HC(HammingComputerM8); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:603:13: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM4>' requested here | |
| HC(HammingComputerM4); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:332:10: warning: 'scan_codes_range' overrides a member function but is not marked 'override' [-Winconsistent-missing-override] | |
| void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:605:13: note: in instantiation of template class 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerDefault>' requested here | |
| HC(HammingComputerDefault); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| ./faiss/IndexBinaryIVF.h:208:18: note: overridden virtual function is here | |
| virtual void scan_codes_range (size_t n, | |
| ^ | |
| IndexBinaryIVF.cpp:673:21: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:673:21: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:689:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer4>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:593:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer4>::IVFBinaryScannerL2' requested here | |
| case 4: HC(HammingComputer4); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer4>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:593:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer4>::IVFBinaryScannerL2' requested here | |
| case 4: HC(HammingComputer4); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer8>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:594:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer8>::IVFBinaryScannerL2' requested here | |
| case 8: HC(HammingComputer8); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer8>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:594:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer8>::IVFBinaryScannerL2' requested here | |
| case 8: HC(HammingComputer8); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer16>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:595:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer16>::IVFBinaryScannerL2' requested here | |
| case 16: HC(HammingComputer16); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer16>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:595:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer16>::IVFBinaryScannerL2' requested here | |
| case 16: HC(HammingComputer16); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer20>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:596:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer20>::IVFBinaryScannerL2' requested here | |
| case 20: HC(HammingComputer20); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer20>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:596:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer20>::IVFBinaryScannerL2' requested here | |
| case 20: HC(HammingComputer20); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer32>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:597:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer32>::IVFBinaryScannerL2' requested here | |
| case 32: HC(HammingComputer32); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer32>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:597:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer32>::IVFBinaryScannerL2' requested here | |
| case 32: HC(HammingComputer32); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer64>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:598:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer64>::IVFBinaryScannerL2' requested here | |
| case 64: HC(HammingComputer64); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer64>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:598:14: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputer64>::IVFBinaryScannerL2' requested here | |
| case 64: HC(HammingComputer64); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM8>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:601:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM8>::IVFBinaryScannerL2' requested here | |
| HC(HammingComputerM8); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM8>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:601:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM8>::IVFBinaryScannerL2' requested here | |
| HC(HammingComputerM8); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM4>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:603:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM4>::IVFBinaryScannerL2' requested here | |
| HC(HammingComputerM4); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM4>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:603:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerM4>::IVFBinaryScannerL2' requested here | |
| HC(HammingComputerM4); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:321:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int32_t' (aka 'int') [-Wsign-compare] | |
| if (dis < simi[0]) { | |
| ~~~ ^ ~~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerDefault>::scan_codes' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:605:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerDefault>::IVFBinaryScannerL2' requested here | |
| HC(HammingComputerDefault); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:341:21: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare] | |
| if (dis < radius) { | |
| ~~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:293:5: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerDefault>::scan_codes_range' requested here | |
| IVFBinaryScannerL2 (size_t code_size, bool store_pairs): | |
| ^ | |
| IndexBinaryIVF.cpp:605:13: note: in instantiation of member function 'faiss::(anonymous namespace)::IVFBinaryScannerL2<faiss::HammingComputerDefault>::IVFBinaryScannerL2' requested here | |
| HC(HammingComputerDefault); | |
| ^ | |
| IndexBinaryIVF.cpp:591:29: note: expanded from macro 'HC' | |
| #define HC(name) return new IVFBinaryScannerL2<name> (code_size, store_pairs) | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:562:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer4, true>' requested here | |
| HANDLE_CS(4); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:563:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer8, true>' requested here | |
| HANDLE_CS(8); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:564:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer16, true>' requested here | |
| HANDLE_CS(16); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:565:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer20, true>' requested here | |
| HANDLE_CS(20); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:566:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer32, true>' requested here | |
| HANDLE_CS(32); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:567:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer64, true>' requested here | |
| HANDLE_CS(64); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:571:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputerM8, true>' requested here | |
| search_knn_hamming_count<HammingComputerM8, store_pairs> | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:574:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputerM4, true>' requested here | |
| search_knn_hamming_count<HammingComputerM4, store_pairs> | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:577:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputerDefault, true>' requested here | |
| search_knn_hamming_count<HammingComputerDefault, store_pairs> | |
| ^ | |
| IndexBinaryIVF.cpp:626:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<true>' requested here | |
| search_knn_hamming_count_1<true> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:562:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer4, false>' requested here | |
| HANDLE_CS(4); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:563:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer8, false>' requested here | |
| HANDLE_CS(8); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:564:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer16, false>' requested here | |
| HANDLE_CS(16); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:565:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer20, false>' requested here | |
| HANDLE_CS(20); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:566:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer32, false>' requested here | |
| HANDLE_CS(32); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:567:7: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputer64, false>' requested here | |
| HANDLE_CS(64); | |
| ^ | |
| IndexBinaryIVF.cpp:559:8: note: expanded from macro 'HANDLE_CS' | |
| search_knn_hamming_count<HammingComputer ## cs, store_pairs>( \ | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:571:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputerM8, false>' requested here | |
| search_knn_hamming_count<HammingComputerM8, store_pairs> | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:574:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputerM4, false>' requested here | |
| search_knn_hamming_count<HammingComputerM4, store_pairs> | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:577:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count<faiss::HammingComputerDefault, false>' requested here | |
| search_knn_hamming_count<HammingComputerDefault, store_pairs> | |
| ^ | |
| IndexBinaryIVF.cpp:629:13: note: in instantiation of function template specialization 'faiss::(anonymous namespace)::search_knn_hamming_count_1<false>' requested here | |
| search_knn_hamming_count_1<false> | |
| ^ | |
| IndexBinaryIVF.cpp:499:9: warning: format specifies type 'long' but the argument has type 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, ivf.nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexBinaryIVF.cpp:490:28: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexBinaryIVF.cpp:519:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| if (max_codes && nscan >= max_codes) | |
| ~~~~~ ^ ~~~~~~~~~ | |
| 119 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexFlat.cpp -o IndexFlat.o | |
| IndexFlat.cpp:246:38: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'const faiss::Index::idx_t' (aka 'const long long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (shift.size() == ntotal); | |
| ~~~~~~~~~~~~ ^ ~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IndexFlat.cpp:422:41: warning: comparison of integers of different signs: 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') and 'const faiss::Index::idx_t' (aka 'const long long') | |
| [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (perm.size() == ntotal, | |
| ~~~~~~~~~~~ ^ ~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| 2 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexHNSW.cpp -o IndexHNSW.o | |
| IndexHNSW.cpp:138:22: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < ntotal; i++) | |
| ~ ^ ~~~~~~ | |
| IndexHNSW.cpp:148:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexHNSW.cpp:151:29: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| while (pt_level >= hist.size()) | |
| ~~~~~~~~ ^ ~~~~~~~~~~~ | |
| IndexHNSW.cpp:158:27: warning: comparison of integers of different signs: 'int' and 'unsigned long' [-Wsign-compare] | |
| for (int i = 0; i < hist.size() - 1; i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~ | |
| IndexHNSW.cpp:163:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexHNSW.cpp:240:22: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < ntotal; i++) { | |
| ~ ^ ~~~~~~ | |
| IndexHNSW.cpp:339:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| for (size_t i = 0; i < k * n; i++) { | |
| ~ ^ ~~~~~ | |
| IndexHNSW.cpp:358:43: warning: comparison of integers of different signs: 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| hnsw.levels.size() == ntotal); | |
| ~~~~~~~~~~~~~~~~~~ ^ ~~~~~~ | |
| IndexHNSW.cpp:497:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < k; j++) { | |
| ~ ^ ~ | |
| IndexHNSW.cpp:628:20: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| n_sing, ntotal, n_sing_l1); | |
| ^~~~~~ | |
| IndexHNSW.cpp:607:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < ntotal; i++) { | |
| ~ ^ ~~~~~~ | |
| IndexHNSW.cpp:631:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < singletons.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~ | |
| IndexHNSW.cpp:679:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < d; l++) | |
| ~ ^ ~ | |
| IndexHNSW.cpp:688:31: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < d; l++) | |
| ~ ^ ~ | |
| IndexHNSW.cpp:703:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < dsub; l++) | |
| ~ ^ ~~~~ | |
| IndexHNSW.cpp:707:30: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = dsub; l < d; l++) | |
| ~ ^ ~ | |
| IndexHNSW.cpp:716:31: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < dsub; l++) | |
| ~ ^ ~~~~ | |
| IndexHNSW.cpp:720:34: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = dsub; l < d; l++) | |
| ~ ^ ~ | |
| IndexHNSW.cpp:728:33: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int sq = 0; sq < nsq; sq++) { | |
| ~~ ^ ~~~ | |
| IndexHNSW.cpp:737:33: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int sq = 0; sq < nsq; sq++) { | |
| ~~ ^ ~~~ | |
| IndexHNSW.cpp:753:33: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int sq = 0; sq < nsq; sq++) { | |
| ~~ ^ ~~~ | |
| IndexHNSW.cpp:785:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexHNSW.cpp:861:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexHNSW.cpp:1061:41: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int jj = 0; jj < list_length; jj++) { | |
| ~~ ^ ~~~~~~~~~~~ | |
| 24 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexIVF.cpp -o IndexIVF.o | |
| IndexIVF.cpp:63:53: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (quantizer->is_trained && (quantizer->ntotal == nlist)) { | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~ | |
| IndexIVF.cpp:71:51: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (quantizer->ntotal == nlist, | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| IndexIVF.cpp:139:49: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (list_no >= 0 && list_no < nlist); | |
| ~~~~~~~ ^ ~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IndexIVF.cpp:162:27: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (d == quantizer->d); | |
| ~ ^ ~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IndexIVF.cpp:163:62: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| is_trained = quantizer->is_trained && (quantizer->ntotal == nlist); | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~ | |
| IndexIVF.cpp:191:63: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| printf(" IndexIVF::add_with_ids %ld:%ld\n", i0, i1); | |
| ~~~ ^~ | |
| %lld | |
| IndexIVF.cpp:191:67: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| printf(" IndexIVF::add_with_ids %ld:%ld\n", i0, i1); | |
| ~~~ ^~ | |
| %lld | |
| IndexIVF.cpp:241:65: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| printf(" added %ld / %ld vectors (%ld -1s)\n", nadd, n, nminus1); | |
| ~~~ ^ | |
| %lld | |
| IndexIVF.cpp:206:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVF.cpp:221:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVF.cpp:350:37: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| key, nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexIVF.cpp:350:37: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| key, nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexIVF.cpp:303:10: warning: unused variable 'do_parallel' [-Wunused-variable] | |
| bool do_parallel = | |
| ^ | |
| IndexIVF.cpp:386:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVF.cpp:402:40: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexIVF.cpp:427:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVF.cpp:432:40: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| for (size_t ik = 0; ik < nprobe; ik++) { | |
| ~~ ^ ~~~~~~ | |
| IndexIVF.cpp:531:19: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexIVF.cpp:531:19: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| key, ik, nlist); | |
| ^~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexIVF.cpp:549:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < nx; i++) { | |
| ~ ^ ~~ | |
| IndexIVF.cpp:562:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < nx; i++) { | |
| ~ ^ ~~ | |
| IndexIVF.cpp:580:50: warning: comparison of integers of different signs: 'faiss::RangeQueryResult::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| if (qres == nullptr || qres->qno != i) { | |
| ~~~~~~~~~ ^ ~ | |
| IndexIVF.cpp:581:46: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::RangeQueryResult::idx_t' (aka 'long long') [-Wsign-compare] | |
| FAISS_ASSERT (!qres || i > qres->qno); | |
| ~ ^ ~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:24:12: note: expanded from macro 'FAISS_ASSERT' | |
| if (! (X)) { \ | |
| ^ | |
| IndexIVF.cpp:623:37: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (idx_t list_no = 0; list_no < nlist; list_no++) { | |
| ~~~~~~~ ^ ~~~~~ | |
| IndexIVF.cpp:627:39: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t offset = 0; offset < list_size; offset++) { | |
| ~~~~~~ ^ ~~~~~~~~~ | |
| IndexIVF.cpp:725:41: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (nremove == n, | |
| ~~~~~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| IndexIVF.cpp:827:37: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (idx_t list_no = 0; list_no < nlist; list_no++) { | |
| ~~~~~~~ ^ ~~~~~ | |
| IndexIVF.cpp:832:33: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVF.cpp:842:33: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVF.cpp:859:34: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = i1; i < i2; i++) { | |
| ~ ^ ~~ | |
| IndexIVF.cpp:871:25: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const faiss::Index::idx_t' (aka 'const long long') [-Wsign-compare] | |
| FAISS_ASSERT(accu_n == ntotal); | |
| ~~~~~~ ^ ~~~~~~ | |
| ./faiss/impl/FaissAssert.h:24:12: note: expanded from macro 'FAISS_ASSERT' | |
| if (! (X)) { \ | |
| ^ | |
| 31 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexIVFFlat.cpp -o IndexIVFFlat.o | |
| IndexIVFFlat.cpp:79:16: warning: format specifies type 'long' but the argument has type 'int64_t' (aka 'long long') [-Wformat] | |
| n_add, n); | |
| ^~~~~ | |
| IndexIVFFlat.cpp:79:23: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| n_add, n); | |
| ^ | |
| IndexIVFFlat.cpp:61:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFFlat.cpp:93:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFFlat.cpp:112:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFFlat.cpp:251:39: warning: format specifies type 'long' but the argument has type 'int64_t' (aka 'long long') [-Wformat] | |
| "(was %ld points)\n", n2, n); | |
| ^~ | |
| IndexIVFFlat.cpp:251:43: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| "(was %ld points)\n", n2, n); | |
| ~~~ ^ | |
| %lld | |
| IndexIVFFlat.cpp:308:16: warning: format specifies type 'long' but the argument has type 'int64_t' (aka 'long long') [-Wformat] | |
| n_add, na, n_dup); | |
| ^~~~~ | |
| IndexIVFFlat.cpp:308:23: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| n_add, na, n_dup); | |
| ^~ | |
| IndexIVFFlat.cpp:308:27: warning: format specifies type 'long' but the argument has type 'int64_t' (aka 'long long') [-Wformat] | |
| n_add, na, n_dup); | |
| ^~~~~ | |
| IndexIVFFlat.cpp:272:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < na; i++) { | |
| ~ ^ ~~ | |
| IndexIVFFlat.cpp:405:27: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| IndexIVFFlat.cpp:431:27: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| 13 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexIVFPQ.cpp -o IndexIVFPQ.o | |
| IndexIVFPQ.cpp:95:32: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| pq.M, pq.ksub, n, d); | |
| ^ | |
| IndexIVFPQ.cpp:169:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| IndexIVFPQ.cpp:197:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFPQ.cpp:243:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFPQ.cpp:250:38: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| IndexIVFPQ.cpp:269:24: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^~ | |
| IndexIVFPQ.cpp:269:28: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^~ | |
| IndexIVFPQ.cpp:269:32: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^ | |
| IndexIVFPQ.cpp:315:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFPQ.cpp:445:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < pq.M; m++) | |
| ~ ^ ~~~~ | |
| IndexIVFPQ.cpp:446:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < pq.ksub; j++) | |
| ~ ^ ~~~~~~~ | |
| IndexIVFPQ.cpp:474:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < cpq.M; m++) { | |
| ~ ^ ~~~~~ | |
| IndexIVFPQ.cpp:702:33: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int cm = 0; cm < cpq.M; cm++) { | |
| ~~ ^ ~~~~~ | |
| IndexIVFPQ.cpp:744:31: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < pq.M; m++) { | |
| ~ ^ ~~~~ | |
| IndexIVFPQ.cpp:759:33: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int cm = 0; cm < cpq.M; cm++) { | |
| ~~ ^ ~~~~~ | |
| IndexIVFPQ.cpp:958:36: warning: unused variable 'nup' [-Wunused-variable] | |
| size_t n_hamming_pass = 0, nup = 0; | |
| ^ | |
| IndexIVFPQ.cpp:1201:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) ord[i] = i; | |
| ~ ^ ~ | |
| IndexIVFPQ.cpp:1208:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| 18 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexIVFPQR.cpp -o IndexIVFPQR.o | |
| IndexIVFPQR.cpp:63:46: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| refine_pq.M, refine_pq.ksub, n, d); | |
| ^ | |
| IndexIVFPQR.cpp:142:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < k_coarse; j++) { | |
| ~ ^ ~~~~~~~~ | |
| IndexIVFPQR.cpp:150:49: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| assert (list_no >= 0 && list_no < nlist); | |
| ~~~~~~~ ^ ~~~~~ | |
| /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/assert.h:93:25: note: expanded from macro 'assert' | |
| (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0) | |
| ^ | |
| IndexIVFPQR.cpp:151:41: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| assert (ofs >= 0 && ofs < invlists->list_size (list_no)); | |
| ~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/assert.h:93:25: note: expanded from macro 'assert' | |
| (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0) | |
| ^ | |
| 4 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexIVFSpectralHash.cpp -o IndexIVFSpectralHash.o | |
| IndexIVFSpectralHash.cpp:97:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFSpectralHash.cpp:103:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < nlist; j++) { | |
| ~ ^ ~~~~~ | |
| IndexIVFSpectralHash.cpp:115:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexIVFSpectralHash.cpp:117:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < nbit; j++) { | |
| ~ ^ ~~~~ | |
| IndexIVFSpectralHash.cpp:125:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| IndexIVFSpectralHash.cpp:181:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| 6 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexLSH.cpp -o IndexLSH.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexLattice.cpp -o IndexLattice.o | |
| IndexLattice.cpp:116:31: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < dsq; l++) { | |
| ~ ^ ~~~ | |
| 1 warning generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexPQ.cpp -o IndexPQ.o | |
| IndexPQ.cpp:64:21: warning: format specifies type 'long' but the argument has type 'long long' [-Wformat] | |
| n - ntrain_perm, ntrain_perm, | |
| ^~~~~~~~~~~~~~~ | |
| IndexPQ.cpp:64:38: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| n - ntrain_perm, ntrain_perm, | |
| ^~~~~~~~~~~ | |
| IndexPQ.cpp:148:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < pq.M; j++) { | |
| ~ ^ ~~~~ | |
| IndexPQ.cpp:163:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < pq.M; l++) { | |
| ~ ^ ~~~~ | |
| IndexPQ.cpp:240:35: warning: comparison of integers of different signs: 'const int' and 'unsigned long' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (d == pq.nbits * pq.M); | |
| ~ ^ ~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| IndexPQ.cpp:242:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:525:32: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t q0 = 0; q0 < n; q0 += bs) { | |
| ~~ ^ ~ | |
| IndexPQ.cpp:528:20: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| if (q1 > n) q1 = n; | |
| ~~ ^ ~ | |
| IndexPQ.cpp:943:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < pq.M; m++) | |
| ~ ^ ~~~~ | |
| IndexPQ.cpp:959:24: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^~ | |
| IndexPQ.cpp:959:28: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^~ | |
| IndexPQ.cpp:959:32: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| i0, i1, n); | |
| ^ | |
| IndexPQ.cpp:982:31: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int s = 0; s < pq.M; s++) { | |
| ~ ^ ~~~~ | |
| IndexPQ.cpp:986:37: warning: comparison of integers of different signs: 'faiss::Index::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (idx_t j = 0; j < pq.ksub; j++) { | |
| ~ ^ ~~~~~~~ | |
| IndexPQ.cpp:1024:23: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < pq.M; m++) { | |
| ~ ^ ~~~~ | |
| IndexPQ.cpp:1065:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < M; i++) { | |
| ~ ^ ~ | |
| IndexPQ.cpp:1067:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| indexes[i]->d == pq.dsub, | |
| ~~~~~~~~~~~~~ ^ ~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| IndexPQ.cpp:1081:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| assign_index_0->d == pq.dsub && | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| IndexPQ.cpp:1082:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| assign_index_1->d == pq.dsub, | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| IndexPQ.cpp:1094:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < pq.M; i++) { | |
| ~ ^ ~~~~ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:383:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputer4>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputer4> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:387:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputer8>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputer8> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:391:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputer16>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputer16> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:395:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputer32>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputer32> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:399:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputer20>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputer20> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:404:31: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputerM8>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputerM8> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:407:31: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::HammingComputerM4>' requested here | |
| n_pass += polysemous_inner_loop<HammingComputerM4> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:419:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::GenHammingComputer8>' requested here | |
| n_pass += polysemous_inner_loop<GenHammingComputer8> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:423:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::GenHammingComputer16>' requested here | |
| n_pass += polysemous_inner_loop<GenHammingComputer16> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:427:27: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::GenHammingComputer32>' requested here | |
| n_pass += polysemous_inner_loop<GenHammingComputer32> | |
| ^ | |
| IndexPQ.cpp:318:29: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t bi = 0; bi < ntotal; bi++) { | |
| ~~ ^ ~~~~~~ | |
| IndexPQ.cpp:432:31: note: in instantiation of function template specialization 'faiss::polysemous_inner_loop<faiss::GenHammingComputerM8>' requested here | |
| n_pass += polysemous_inner_loop<GenHammingComputerM8> | |
| ^ | |
| 32 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexPreTransform.cpp -o IndexPreTransform.o | |
| IndexPreTransform.cpp:64:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::VectorTransform *, std::__1::allocator<faiss::VectorTransform *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < chain.size(); i++) | |
| ~ ^ ~~~~~~~~~~~~ | |
| IndexPreTransform.cpp:96:15: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::VectorTransform *, std::__1::allocator<faiss::VectorTransform *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| if (i < chain.size()) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| IndexPreTransform.cpp:136:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::VectorTransform *, std::__1::allocator<faiss::VectorTransform *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < chain.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| 3 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexReplicas.cpp -o IndexReplicas.o | |
| In file included from IndexReplicas.cpp:8: | |
| In file included from ./faiss/IndexReplicas.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| IndexReplicas.cpp:120:10: warning: struct template 'IndexReplicasTemplate' was previously declared as a class template; this is valid, but may result in linker errors under the Microsoft C++ ABI [-Wmismatched-tags] | |
| template struct IndexReplicasTemplate<Index>; | |
| ^ | |
| ./faiss/IndexReplicas.h:21:7: note: previous use is here | |
| class IndexReplicasTemplate : public ThreadedIndex<IndexT> { | |
| ^ | |
| IndexReplicas.cpp:120:10: note: did you mean class here? | |
| template struct IndexReplicasTemplate<Index>; | |
| ^~~~~~ | |
| class | |
| IndexReplicas.cpp:40:28: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:120:17: note: in instantiation of member function 'faiss::IndexReplicasTemplate<faiss::Index>::onAfterAddIndex' requested here | |
| template struct IndexReplicasTemplate<Index>; | |
| ^ | |
| IndexReplicas.cpp:40:46: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:40:28: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:40:46: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:121:10: warning: struct template 'IndexReplicasTemplate' was previously declared as a class template; this is valid, but may result in linker errors under the Microsoft C++ ABI [-Wmismatched-tags] | |
| template struct IndexReplicasTemplate<IndexBinary>; | |
| ^ | |
| ./faiss/IndexReplicas.h:21:7: note: previous use is here | |
| class IndexReplicasTemplate : public ThreadedIndex<IndexT> { | |
| ^ | |
| IndexReplicas.cpp:121:10: note: did you mean class here? | |
| template struct IndexReplicasTemplate<IndexBinary>; | |
| ^~~~~~ | |
| class | |
| IndexReplicas.cpp:40:28: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:121:17: note: in instantiation of member function 'faiss::IndexReplicasTemplate<faiss::IndexBinary>::onAfterAddIndex' requested here | |
| template struct IndexReplicasTemplate<IndexBinary>; | |
| ^ | |
| IndexReplicas.cpp:40:46: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:40:28: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| IndexReplicas.cpp:40:46: warning: format specifies type 'long' but the argument has type 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wformat] | |
| existing->ntotal, index->ntotal); | |
| ^~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:91:55: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| In file included from IndexReplicas.cpp:8: | |
| In file included from ./faiss/IndexReplicas.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:123:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| IndexReplicas.cpp:58:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::runOnIndex' requested here | |
| this->runOnIndex([n, x](int, IndexT* index){ index->train(n, x); }); | |
| ^ | |
| In file included from IndexReplicas.cpp:8: | |
| In file included from ./faiss/IndexReplicas.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:135:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:179:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::future<bool>, std::__1::allocator<std::__1::future<bool> > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < v.size(); ++i) { | |
| ~ ^ ~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:129:5: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::waitAndHandleFutures' requested here | |
| waitAndHandleFutures(v); | |
| ^ | |
| IndexReplicas.cpp:58:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::runOnIndex' requested here | |
| this->runOnIndex([n, x](int, IndexT* index){ index->train(n, x); }); | |
| ^ | |
| In file included from IndexReplicas.cpp:8: | |
| In file included from ./faiss/IndexReplicas.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:123:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' | |
| (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| IndexReplicas.cpp:58:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::IndexBinary>::runOnIndex' requested here | |
| this->runOnIndex([n, x](int, IndexT* index){ index->train(n, x); }); | |
| ^ | |
| In file included from IndexReplicas.cpp:8: | |
| In file included from ./faiss/IndexReplicas.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:135:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' | |
| (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:179:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::future<bool>, std::__1::allocator<std::__1::future<bool> > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < v.size(); ++i) { | |
| ~ ^ ~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:129:5: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::IndexBinary>::waitAndHandleFutures' requested here | |
| waitAndHandleFutures(v); | |
| ^ | |
| IndexReplicas.cpp:58:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::IndexBinary>::runOnIndex' requested here | |
| this->runOnIndex([n, x](int, IndexT* index){ index->train(n, x); }); | |
| ^ | |
| 18 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexScalarQuantizer.cpp -o IndexScalarQuantizer.o | |
| IndexScalarQuantizer.cpp:80:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexScalarQuantizer.cpp:125:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < ni; i++) { | |
| ~ ^ ~~ | |
| IndexScalarQuantizer.cpp:200:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexScalarQuantizer.cpp:230:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| IndexScalarQuantizer.cpp:237:38: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| IndexScalarQuantizer.cpp:266:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| 6 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c IndexShards.cpp -o IndexShards.o | |
| In file included from IndexShards.cpp:10: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| IndexShards.cpp:134:54: warning: unused parameter 'index' [-Wunused-parameter] | |
| IndexShardsTemplate<IndexT>::onAfterAddIndex(IndexT* index /* unused */) { | |
| ^ | |
| IndexShards.cpp:140:57: warning: unused parameter 'index' [-Wunused-parameter] | |
| IndexShardsTemplate<IndexT>::onAfterRemoveIndex(IndexT* index /* unused */) { | |
| ^ | |
| IndexShards.cpp:240:59: warning: format specifies type 'long' but the argument has type 'faiss::IndexShardsTemplate<faiss::Index>::idx_t' (aka 'long long') [-Wformat] | |
| printf ("begin add shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| IndexShards.cpp:314:17: note: in instantiation of member function 'faiss::IndexShardsTemplate<faiss::Index>::add_with_ids' requested here | |
| template struct IndexShardsTemplate<Index>; | |
| ^ | |
| IndexShards.cpp:250:57: warning: format specifies type 'long' but the argument has type 'long long' [-Wformat] | |
| printf ("end add shard %d on %ld points\n", no, i1 - i0); | |
| ~~~ ^~~~~~~ | |
| %lld | |
| IndexShards.cpp:276:61: warning: format specifies type 'long' but the argument has type 'faiss::IndexShardsTemplate<faiss::Index>::idx_t' (aka 'long long') [-Wformat] | |
| printf ("begin query shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| IndexShards.cpp:314:17: note: in instantiation of member function 'faiss::IndexShardsTemplate<faiss::Index>::search' requested here | |
| template struct IndexShardsTemplate<Index>; | |
| ^ | |
| IndexShards.cpp:175:60: warning: format specifies type 'long' but the argument has type 'faiss::IndexShardsTemplate<faiss::Index>::idx_t' (aka 'long long') [-Wformat] | |
| printf("begin train shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| IndexShards.cpp:314:17: note: in instantiation of member function 'faiss::IndexShardsTemplate<faiss::Index>::train' requested here | |
| template struct IndexShardsTemplate<Index>; | |
| ^ | |
| IndexShards.cpp:240:59: warning: format specifies type 'long' but the argument has type 'faiss::IndexShardsTemplate<faiss::IndexBinary>::idx_t' (aka 'long long') [-Wformat] | |
| printf ("begin add shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| IndexShards.cpp:315:17: note: in instantiation of member function 'faiss::IndexShardsTemplate<faiss::IndexBinary>::add_with_ids' requested here | |
| template struct IndexShardsTemplate<IndexBinary>; | |
| ^ | |
| IndexShards.cpp:250:57: warning: format specifies type 'long' but the argument has type 'long long' [-Wformat] | |
| printf ("end add shard %d on %ld points\n", no, i1 - i0); | |
| ~~~ ^~~~~~~ | |
| %lld | |
| IndexShards.cpp:276:61: warning: format specifies type 'long' but the argument has type 'faiss::IndexShardsTemplate<faiss::IndexBinary>::idx_t' (aka 'long long') [-Wformat] | |
| printf ("begin query shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| IndexShards.cpp:315:17: note: in instantiation of member function 'faiss::IndexShardsTemplate<faiss::IndexBinary>::search' requested here | |
| template struct IndexShardsTemplate<IndexBinary>; | |
| ^ | |
| IndexShards.cpp:175:60: warning: format specifies type 'long' but the argument has type 'faiss::IndexShardsTemplate<faiss::IndexBinary>::idx_t' (aka 'long long') [-Wformat] | |
| printf("begin train shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| IndexShards.cpp:315:17: note: in instantiation of member function 'faiss::IndexShardsTemplate<faiss::IndexBinary>::train' requested here | |
| template struct IndexShardsTemplate<IndexBinary>; | |
| ^ | |
| In file included from IndexShards.cpp:10: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:123:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| IndexShards.cpp:254:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::runOnIndex' requested here | |
| this->runOnIndex(fn); | |
| ^ | |
| In file included from IndexShards.cpp:10: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:135:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::Index *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:179:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::future<bool>, std::__1::allocator<std::__1::future<bool> > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < v.size(); ++i) { | |
| ~ ^ ~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:129:5: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::waitAndHandleFutures' requested here | |
| waitAndHandleFutures(v); | |
| ^ | |
| IndexShards.cpp:254:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::Index>::runOnIndex' requested here | |
| this->runOnIndex(fn); | |
| ^ | |
| In file included from IndexShards.cpp:10: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:123:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' | |
| (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| IndexShards.cpp:254:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::IndexBinary>::runOnIndex' requested here | |
| this->runOnIndex(fn); | |
| ^ | |
| In file included from IndexShards.cpp:10: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:135:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, | |
| std::__1::default_delete<faiss::WorkerThread> > >, std::__1::allocator<std::__1::pair<faiss::IndexBinary *, std::__1::unique_ptr<faiss::WorkerThread, std::__1::default_delete<faiss::WorkerThread> > > > >::size_type' | |
| (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < this->indices_.size(); ++i) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:179:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<std::__1::future<bool>, std::__1::allocator<std::__1::future<bool> > >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < v.size(); ++i) { | |
| ~ ^ ~~~~~~~~ | |
| ./faiss/impl/ThreadedIndex-inl.h:129:5: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::IndexBinary>::waitAndHandleFutures' requested here | |
| waitAndHandleFutures(v); | |
| ^ | |
| IndexShards.cpp:254:9: note: in instantiation of member function 'faiss::ThreadedIndex<faiss::IndexBinary>::runOnIndex' requested here | |
| this->runOnIndex(fn); | |
| ^ | |
| IndexShards.cpp:28:6: warning: unused function 'translate_labels' [-Wunused-function] | |
| void translate_labels (long n, idx_t *labels, long translation) | |
| ^ | |
| 19 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c InvertedLists.cpp -o InvertedLists.o | |
| InvertedLists.cpp:78:25: warning: comparison of integers of different signs: 'faiss::InvertedLists::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < nlist; i++) { | |
| ~ ^ ~~~~~ | |
| InvertedLists.cpp:241:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ils.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:252:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ils.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:266:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ils.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:289:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ils.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:304:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ils.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:322:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ils.size(); i++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:339:53: warning: comparison of integers of different signs: 'faiss::(anonymous namespace)::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (list_no >= 0 && list_no < sil->nlist); | |
| ~~~~~~~ ^ ~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| InvertedLists.cpp:417:53: warning: comparison of integers of different signs: 'faiss::(anonymous namespace)::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (list_no >= 0 && list_no < vil->nlist); | |
| ~~~~~~~ ^ ~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| InvertedLists.cpp:522:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < ils.size(); j++) { | |
| ~ ^ ~~~~~~~~~~ | |
| InvertedLists.cpp:535:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<const faiss::InvertedLists *, std::__1::allocator<const faiss::InvertedLists *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < ils.size(); j++) { | |
| ~ ^ ~~~~~~~~~~ | |
| 11 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c MatrixStats.cpp -o MatrixStats.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c MetaIndexes.cpp -o MetaIndexes.o | |
| In file included from MetaIndexes.cpp:10: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| MetaIndexes.cpp:103:23: warning: comparison of integers of different signs: 'faiss::IndexIDMapTemplate<faiss::Index>::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < result->lims[result->nq]; i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~ | |
| MetaIndexes.cpp:209:17: note: in instantiation of member function 'faiss::IndexIDMapTemplate<faiss::Index>::range_search' requested here | |
| template struct IndexIDMapTemplate<Index>; | |
| ^ | |
| MetaIndexes.cpp:103:23: warning: comparison of integers of different signs: 'faiss::IndexIDMapTemplate<faiss::IndexBinary>::idx_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < result->lims[result->nq]; i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~ | |
| MetaIndexes.cpp:210:17: note: in instantiation of member function 'faiss::IndexIDMapTemplate<faiss::IndexBinary>::range_search' requested here | |
| template struct IndexIDMapTemplate<IndexBinary>; | |
| ^ | |
| MetaIndexes.cpp:180:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < this->ntotal; i++) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| MetaIndexes.cpp:211:17: note: in instantiation of member function 'faiss::IndexIDMap2Template<faiss::Index>::construct_rev_map' requested here | |
| template struct IndexIDMap2Template<Index>; | |
| ^ | |
| MetaIndexes.cpp:171:36: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = prev_ntotal; i < this->ntotal; i++) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| MetaIndexes.cpp:211:17: note: in instantiation of member function 'faiss::IndexIDMap2Template<faiss::Index>::add_with_ids' requested here | |
| template struct IndexIDMap2Template<Index>; | |
| ^ | |
| MetaIndexes.cpp:202:47: warning: format specifies type 'long' but the argument has type 'faiss::IndexIDMap2Template<faiss::Index>::idx_t' (aka 'long long') [-Wformat] | |
| FAISS_THROW_FMT ("key %ld not found", key); | |
| ~~~ ^~~ | |
| %lld | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| MetaIndexes.cpp:211:17: note: in instantiation of member function 'faiss::IndexIDMap2Template<faiss::Index>::reconstruct' requested here | |
| template struct IndexIDMap2Template<Index>; | |
| ^ | |
| MetaIndexes.cpp:202:47: warning: format specifies type 'long' but the argument has type 'faiss::IndexIDMap2Template<faiss::Index>::idx_t' (aka 'long long') [-Wformat] | |
| FAISS_THROW_FMT ("key %ld not found", key); | |
| ~~~ ^~~ | |
| %lld | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| MetaIndexes.cpp:180:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < this->ntotal; i++) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| MetaIndexes.cpp:212:17: note: in instantiation of member function 'faiss::IndexIDMap2Template<faiss::IndexBinary>::construct_rev_map' requested here | |
| template struct IndexIDMap2Template<IndexBinary>; | |
| ^ | |
| MetaIndexes.cpp:171:36: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::IndexBinary::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = prev_ntotal; i < this->ntotal; i++) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| MetaIndexes.cpp:212:17: note: in instantiation of member function 'faiss::IndexIDMap2Template<faiss::IndexBinary>::add_with_ids' requested here | |
| template struct IndexIDMap2Template<IndexBinary>; | |
| ^ | |
| MetaIndexes.cpp:202:47: warning: format specifies type 'long' but the argument has type 'faiss::IndexIDMap2Template<faiss::IndexBinary>::idx_t' (aka 'long long') [-Wformat] | |
| FAISS_THROW_FMT ("key %ld not found", key); | |
| ~~~ ^~~ | |
| %lld | |
| ./faiss/impl/FaissAssert.h:64:44: note: expanded from macro 'FAISS_THROW_FMT' | |
| int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| MetaIndexes.cpp:212:17: note: in instantiation of member function 'faiss::IndexIDMap2Template<faiss::IndexBinary>::reconstruct' requested here | |
| template struct IndexIDMap2Template<IndexBinary>; | |
| ^ | |
| MetaIndexes.cpp:202:47: warning: format specifies type 'long' but the argument has type 'faiss::IndexIDMap2Template<faiss::IndexBinary>::idx_t' (aka 'long long') [-Wformat] | |
| FAISS_THROW_FMT ("key %ld not found", key); | |
| ~~~ ^~~ | |
| %lld | |
| ./faiss/impl/FaissAssert.h:66:40: note: expanded from macro 'FAISS_THROW_FMT' | |
| snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__); \ | |
| ~~~ ^~~~~~~~~~~ | |
| MetaIndexes.cpp:241:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::Index *, std::__1::allocator<faiss::Index *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 1; i < sub_indexes.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~ | |
| MetaIndexes.cpp:277:65: warning: format specifies type 'long' but the argument has type 'faiss::Index::idx_t' (aka 'long long') [-Wformat] | |
| printf ("begin query shard %d on %ld points\n", no, n); | |
| ~~~ ^ | |
| %lld | |
| MetaIndexes.cpp:344:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::Index *, std::__1::allocator<faiss::Index *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int s = 0; s < sub_indexes.size(); s++) | |
| ~ ^ ~~~~~~~~~~~~~~~~~~ | |
| 15 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c OnDiskInvertedLists.cpp -o OnDiskInvertedLists.o | |
| OnDiskInvertedLists.cpp:114:38: warning: comparison of integers of different signs: 'std::__1::unordered_set<int, std::__1::hash<int>, std::__1::equal_to<int>, std::__1::allocator<int> >::size_type' (aka 'unsigned long') and 'int' | |
| [-Wsign-compare] | |
| while (level1_holders.size() > n_level2) { | |
| ~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~ | |
| OnDiskInvertedLists.cpp:164:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::InvertedLists::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n8;i++) { | |
| ~ ^ ~~ | |
| OnDiskInvertedLists.cpp:207:39: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| if (cur_list >= 0 && cur_list < list_ids.size()) { | |
| ~~~~~~~~ ^ ~~~~~~~~~~~~~~~ | |
| 3 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c VectorTransform.cpp -o VectorTransform.o | |
| VectorTransform.cpp:129:42: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (b.size() == d_out, "Bias not initialized"); | |
| ~~~~~~~~ ^ ~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| VectorTransform.cpp:139:38: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT_MSG (A.size() == d_out * d_in, | |
| ~~~~~~~~ ^ ~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:83:11: note: expanded from macro 'FAISS_THROW_IF_NOT_MSG' | |
| if (!(X)) { \ | |
| ^ | |
| VectorTransform.cpp:189:27: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_ASSERT(A.size() >= d_out * d_in); | |
| ~~~~~~~~ ^ ~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:24:12: note: expanded from macro 'FAISS_ASSERT' | |
| if (! (X)) { \ | |
| ^ | |
| VectorTransform.cpp:232:36: warning: comparison of integers of different signs: 'std::__1::vector<double, std::__1::allocator<double> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (mat.size() >= n * d); | |
| ~~~~~~~~~~ ^ ~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| VectorTransform.cpp:326:30: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int j = 0; j < d_in; j++) printf("%g ", eigenvalues[j]); | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:331:30: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < d_in; i++) { | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:332:34: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int j = 0; j < d_in; j++) | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:342:22: warning: comparison of integers of different signs: 'int' and 'unsigned long' [-Wsign-compare] | |
| for(int i = 0; i < d_in / 2; i++) { | |
| ~ ^ ~~~~~~~~ | |
| VectorTransform.cpp:347:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int j = 0; j < d_in; j++) | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:411:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t i = 0; i < d_in * d_in; i++) covd [i] = cov [i]; | |
| ~ ^ ~~~~~~~~~~~ | |
| VectorTransform.cpp:417:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t i = 0; i < d_in * d_in; i++) PCAMat [i] = covd [i]; | |
| ~ ^ ~~~~~~~~~~~ | |
| VectorTransform.cpp:420:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t i = 0; i < d_in; i++) | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:428:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) | |
| ~ ^ ~ | |
| VectorTransform.cpp:429:33: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for(size_t j = 0; j < d_in; j++) | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:452:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| for (size_t i = 0; i < n * n; i++) | |
| ~ ^ ~~~~~ | |
| VectorTransform.cpp:463:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| for (size_t i = 0; i < n * n; i++) | |
| ~ ^ ~~~~~ | |
| VectorTransform.cpp:468:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) | |
| ~ ^ ~ | |
| VectorTransform.cpp:511:26: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| d_out * d_in <= PCAMat.size(), | |
| ~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| VectorTransform.cpp:871:20: warning: format specifies type 'long' but the argument has type 'Index::idx_t' (aka 'long long') [-Wformat] | |
| M, n, d_in, d_out); | |
| ^ | |
| VectorTransform.cpp:879:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| VectorTransform.cpp:883:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < d; i++) sum[i] /= n; | |
| ~ ^ ~ | |
| VectorTransform.cpp:886:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'Index::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| VectorTransform.cpp:999:11: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (d > d_in) { | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:1055:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < d_in; j++) { | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:1060:26: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < d_in; j++) { | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:1073:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t j = 0; j < d_in; j++) { | |
| ~ ^ ~~~~ | |
| VectorTransform.cpp:1085:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'const int' [-Wsign-compare] | |
| for (size_t j = 0; j < d_in; j++) { | |
| ~ ^ ~~~~ | |
| 27 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c clone_index.cpp -o clone_index.o | |
| In file included from clone_index.cpp:28: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| clone_index.cpp:117:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::VectorTransform *, std::__1::allocator<faiss::VectorTransform *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ipt->chain.size(); i++) | |
| ~ ^ ~~~~~~~~~~~~~~~~~ | |
| 3 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c index_factory.cpp -o index_factory.o | |
| In file included from index_factory.cpp:33: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| index_factory.cpp:54:27: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::VectorTransform *, std::__1::allocator<faiss::VectorTransform *> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < chain.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~ | |
| index_factory.cpp:142:50: warning: format specifies type 'long *' but the argument has type 'int64_t *' (aka 'long long *') [-Wformat] | |
| sscanf (tok, "IVF%ld_HNSW%d", &ncentroids, &M) == 2) { | |
| ~~~ ^~~~~~~~~~~ | |
| %lld | |
| index_factory.cpp:147:43: warning: format specifies type 'long *' but the argument has type 'int64_t *' (aka 'long long *') [-Wformat] | |
| sscanf (tok, "IVF%ld", &ncentroids) == 1) { | |
| ~~~ ^~~~~~~~~~~ | |
| %lld | |
| index_factory.cpp:168:48: warning: format specifies type 'long *' but the argument has type 'int64_t *' (aka 'long long *') [-Wformat] | |
| sscanf (tok, "Residual%ld", &ncentroids) == 1) { | |
| ~~~ ^~~~~~~~~~~ | |
| %lld | |
| 6 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/AuxIndexStructures.cpp -o impl/AuxIndexStructures.o | |
| impl/AuxIndexStructures.cpp:40:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < nq; i++) { | |
| ~ ^ ~~ | |
| impl/AuxIndexStructures.cpp:73:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::BufferList::Buffer, std::__1::allocator<faiss::BufferList::Buffer> >::size_type' (aka 'unsigned long') | |
| [-Wsign-compare] | |
| for (int i = 0; i < buffers.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| impl/AuxIndexStructures.cpp:161:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::RangeQueryResult, std::__1::allocator<faiss::RangeQueryResult> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < queries.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| impl/AuxIndexStructures.cpp:171:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::RangeQueryResult, std::__1::allocator<faiss::RangeQueryResult> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < queries.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| impl/AuxIndexStructures.cpp:242:25: warning: comparison of integers of different signs: 'faiss::IDSelector::idx_t' (aka 'long long') and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (idx_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/AuxIndexStructures.cpp:262:24: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (long i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| 6 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/FaissException.cpp -o impl/FaissException.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/HNSW.cpp -o impl/HNSW.o | |
| impl/HNSW.cpp:33:32: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = level_no + 1; i < cum_nneighbor_per_level.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/HNSW.cpp:68:29: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<double, std::__1::allocator<double> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int level = 0; level < assign_probas.size(); level++) { | |
| ~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~ | |
| impl/HNSW.cpp:93:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < levels.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~ | |
| impl/HNSW.cpp:116:29: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (level < cum_nneighbor_per_level.size()); | |
| ~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/HNSW.cpp:122:21: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < levels.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~ | |
| impl/HNSW.cpp:179:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/HNSW.cpp:189:25: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int ii = 0; ii < elts.size(); ii++) { | |
| ~~ ^ ~~~~~~~~~~~ | |
| impl/HNSW.cpp:214:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/HNSW.cpp:221:21: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/HNSW.cpp:260:25: warning: comparison of integers of different signs: 'std::__1::vector<faiss::HNSW::NodeDistFarther, std::__1::allocator<faiss::HNSW::NodeDistFarther> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (output.size() >= max_size) { | |
| ~~~~~~~~~~~~~ ^ ~~~~~~~~ | |
| impl/HNSW.cpp:287:27: warning: comparison of integers of different signs: 'std::__1::priority_queue<faiss::HNSW::NodeDistCloser, std::__1::vector<faiss::HNSW::NodeDistCloser, std::__1::allocator<faiss::HNSW::NodeDistCloser> >, | |
| std::__1::less<faiss::HNSW::NodeDistCloser> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (resultSet1.size() < max_size) { | |
| ~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~ | |
| impl/HNSW.cpp:391:26: warning: comparison of integers of different signs: 'std::__1::priority_queue<faiss::HNSW::NodeDistCloser, std::__1::vector<faiss::HNSW::NodeDistCloser, std::__1::allocator<faiss::HNSW::NodeDistCloser> >, | |
| std::__1::less<faiss::HNSW::NodeDistCloser> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (results.size() < hnsw.efConstruction || | |
| ~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~ | |
| impl/HNSW.cpp:396:28: warning: comparison of integers of different signs: 'std::__1::priority_queue<faiss::HNSW::NodeDistCloser, std::__1::vector<faiss::HNSW::NodeDistCloser, std::__1::allocator<faiss::HNSW::NodeDistCloser> >, | |
| std::__1::less<faiss::HNSW::NodeDistCloser> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (results.size() > hnsw.efConstruction) { | |
| ~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~ | |
| impl/HNSW.cpp:655:68: warning: comparison of integers of different signs: 'std::__1::priority_queue<std::__1::pair<float, int>, std::__1::vector<std::__1::pair<float, int>, std::__1::allocator<std::__1::pair<float, int> > >, | |
| std::__1::less<std::__1::pair<float, int> > >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (top_candidates.top().first > d1 || top_candidates.size() < ef) { | |
| ~~~~~~~~~~~~~~~~~~~~~ ^ ~~ | |
| impl/HNSW.cpp:659:35: warning: comparison of integers of different signs: 'std::__1::priority_queue<std::__1::pair<float, int>, std::__1::vector<std::__1::pair<float, int>, std::__1::allocator<std::__1::pair<float, int> > >, | |
| std::__1::less<std::__1::pair<float, int> > >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (top_candidates.size() > ef) { | |
| ~~~~~~~~~~~~~~~~~~~~~ ^ ~~ | |
| impl/HNSW.cpp:704:36: warning: comparison of integers of different signs: 'std::__1::priority_queue<std::__1::pair<float, int>, std::__1::vector<std::__1::pair<float, int>, std::__1::allocator<std::__1::pair<float, int> > >, | |
| std::__1::less<std::__1::pair<float, int> > >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| while (top_candidates.size() > k) { | |
| ~~~~~~~~~~~~~~~~~~~~~ ^ ~ | |
| 16 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/PolysemousTraining.cpp -o impl/PolysemousTraining.o | |
| impl/PolysemousTraining.cpp:269:46: warning: comparison of integers of different signs: 'std::__1::vector<double, std::__1::allocator<double> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (dis_table.size() == n * n); | |
| ~~~~~~~~~~~~~~~~ ^ ~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/PolysemousTraining.cpp:402:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n2; i++) { | |
| ~ ^ ~~ | |
| impl/PolysemousTraining.cpp:698:31: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<int, std::__1::allocator<int> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int k = j; k < b.size(); k++) | |
| ~ ^ ~~~~~~~~ | |
| impl/PolysemousTraining.cpp:777:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < pq.M; m++) { | |
| ~ ^ ~~~~ | |
| impl/PolysemousTraining.cpp:848:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < pq.M; m++) { | |
| ~ ^ ~~~~ | |
| impl/PolysemousTraining.cpp:855:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) | |
| ~ ^ ~ | |
| impl/PolysemousTraining.cpp:861:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < n; i++) | |
| ~ ^ ~ | |
| impl/PolysemousTraining.cpp:877:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < nq; i++) | |
| ~ ^ ~~ | |
| impl/PolysemousTraining.cpp:923:27: warning: comparison of integers of different signs: 'int' and 'unsigned long' [-Wsign-compare] | |
| for (int i = 0; i < dsub * pq.ksub; i++) | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| impl/PolysemousTraining.cpp:926:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < pq.ksub; i++) | |
| ~ ^ ~~~~~~~ | |
| 10 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/ProductQuantizer.cpp -o impl/ProductQuantizer.o | |
| impl/ProductQuantizer.cpp:56:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t m = 0; m < M; m+=4) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:130:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:271:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:323:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:432:57: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (assign_index && assign_index->d == dsub); | |
| ~~~~~~~~~~~~~~~ ^ ~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/ProductQuantizer.cpp:561:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:587:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:699:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:705:27: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < ksub; i++) { | |
| ~ ^ ~~~~ | |
| impl/ProductQuantizer.cpp:707:31: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int j = 0; j < ksub; j++) { | |
| ~ ^ ~~~~ | |
| impl/ProductQuantizer.cpp:710:35: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int k = 0; k < dsub; k++) | |
| ~ ^ ~~~~ | |
| impl/ProductQuantizer.cpp:745:31: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:130:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:631:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned char, faiss::CMax<float, long long> >' requested here | |
| pq_estimators_from_tables<uint8_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:670:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMax<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMax<float, int64_t>> ( | |
| ^ | |
| impl/ProductQuantizer.cpp:56:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t m = 0; m < M; m+=4) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:118:9: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables_Mmul4<unsigned char, faiss::CMax<float, long long> >' requested here | |
| pq_estimators_from_tables_Mmul4<CT, C> (pq.M, codes, ncodes, | |
| ^ | |
| impl/ProductQuantizer.cpp:631:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned char, faiss::CMax<float, long long> >' requested here | |
| pq_estimators_from_tables<uint8_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:670:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMax<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMax<float, int64_t>> ( | |
| ^ | |
| impl/ProductQuantizer.cpp:130:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:638:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned short, faiss::CMax<float, long long> >' requested here | |
| pq_estimators_from_tables<uint16_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:670:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMax<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMax<float, int64_t>> ( | |
| ^ | |
| impl/ProductQuantizer.cpp:56:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t m = 0; m < M; m+=4) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:118:9: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables_Mmul4<unsigned short, faiss::CMax<float, long long> >' requested here | |
| pq_estimators_from_tables_Mmul4<CT, C> (pq.M, codes, ncodes, | |
| ^ | |
| impl/ProductQuantizer.cpp:638:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned short, faiss::CMax<float, long long> >' requested here | |
| pq_estimators_from_tables<uint16_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:670:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMax<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMax<float, int64_t>> ( | |
| ^ | |
| impl/ProductQuantizer.cpp:130:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:631:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned char, faiss::CMin<float, long long> >' requested here | |
| pq_estimators_from_tables<uint8_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:685:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMin<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMin<float, int64_t> > ( | |
| ^ | |
| impl/ProductQuantizer.cpp:56:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t m = 0; m < M; m+=4) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:118:9: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables_Mmul4<unsigned char, faiss::CMin<float, long long> >' requested here | |
| pq_estimators_from_tables_Mmul4<CT, C> (pq.M, codes, ncodes, | |
| ^ | |
| impl/ProductQuantizer.cpp:631:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned char, faiss::CMin<float, long long> >' requested here | |
| pq_estimators_from_tables<uint8_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:685:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMin<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMin<float, int64_t> > ( | |
| ^ | |
| impl/ProductQuantizer.cpp:130:27: warning: comparison of integers of different signs: 'int' and 'const size_t' (aka 'const unsigned long') [-Wsign-compare] | |
| for (int m = 0; m < M; m++) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:638:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned short, faiss::CMin<float, long long> >' requested here | |
| pq_estimators_from_tables<uint16_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:685:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMin<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMin<float, int64_t> > ( | |
| ^ | |
| impl/ProductQuantizer.cpp:56:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t m = 0; m < M; m+=4) { | |
| ~ ^ ~ | |
| impl/ProductQuantizer.cpp:118:9: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables_Mmul4<unsigned short, faiss::CMin<float, long long> >' requested here | |
| pq_estimators_from_tables_Mmul4<CT, C> (pq.M, codes, ncodes, | |
| ^ | |
| impl/ProductQuantizer.cpp:638:15: note: in instantiation of function template specialization 'faiss::pq_estimators_from_tables<unsigned short, faiss::CMin<float, long long> >' requested here | |
| pq_estimators_from_tables<uint16_t, C> (pq, | |
| ^ | |
| impl/ProductQuantizer.cpp:685:5: note: in instantiation of function template specialization 'faiss::pq_knn_search_with_tables<faiss::CMin<float, long long> >' requested here | |
| pq_knn_search_with_tables<CMin<float, int64_t> > ( | |
| ^ | |
| 20 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/ScalarQuantizer.cpp -o impl/ScalarQuantizer.o | |
| impl/ScalarQuantizer.cpp:582:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:591:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:617:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:682:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 1; i < n; i++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:684:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:690:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:699:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'faiss::(anonymous namespace)::idx_t' (aka 'long long') [-Wsign-compare] | |
| for (size_t i = 1; i < n; i++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:701:34: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| impl/ScalarQuantizer.cpp:707:30: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| for (size_t j = 0; j < d; j++) { | |
| ~ ^ ~ | |
| 9 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/index_read.cpp -o impl/index_read.o | |
| In file included from impl/index_read.cpp:35: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| impl/index_read.cpp:116:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (pca->mean); | |
| ^~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:117:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (pca->eigenvalues); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:118:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (pca->PCAMat); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:129:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (lt->A); | |
| ^~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:130:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (lt->b); | |
| ^~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:131:42: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (lt->A.size() >= lt->d_in * lt->d_out); | |
| ~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:132:60: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (!lt->have_bias || lt->b.size() >= lt->d_out); | |
| ~~~~~~~~~~~~ ^ ~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:137:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (rdt->map); | |
| ^~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:145:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ct->mean); | |
| ^~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:150:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (itqt->mean); | |
| ^~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:184:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (sizes); | |
| ^~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:188:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idsizes); | |
| ^~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:271:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (od->lists); | |
| ^~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:274:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR(v); | |
| ^~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:279:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR(x); | |
| ^~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:328:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (pq->centroids); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:337:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ivsc->trained); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:342:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (hnsw->assign_probas); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:343:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (hnsw->cum_nneighbor_per_level); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:344:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (hnsw->levels); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:345:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (hnsw->offsets); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:346:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (hnsw->neighbors); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:373:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (dm->array); | |
| ^~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:377:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (v); | |
| ^~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:400:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR ((*ids)[i]); | |
| ^~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:435:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ail->codes[i]); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:447:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ivfpqr->refine_codes); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:470:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxf->xb); | |
| ^~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:471:45: warning: comparison of integers of different signs: 'std::__1::vector<float, std::__1::allocator<float> >::size_type' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (idxf->xb.size() == idxf->ntotal * idxf->d); | |
| ~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:480:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxl->thresholds); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:497:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxl->codes); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:501:35: warning: comparison of integers of different signs: 'std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >::size_type' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| idxl->codes.size() == idxl->ntotal * idxl->bytes_per_vec); | |
| ~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:509:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxp->codes); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:531:17: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ail->codes[i]); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:536:17: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (vec); | |
| ^~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:549:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (tab); | |
| ^~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:550:32: warning: comparison of integers of different signs: 'long' and 'std::__1::vector<long long, std::__1::allocator<long long> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (long i = 0; i < tab.size(); i += 2) { | |
| ~ ^ ~~~~~~~~~~ | |
| impl/index_read.cpp:568:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxs->codes); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:579:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxl->trained); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:588:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < ivsc->nlist; i++) | |
| ~ ^ ~~~~~~~~~~~ | |
| impl/index_read.cpp:589:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ail->codes[i]); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:613:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (ivsp->trained); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:657:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxmap->id_map); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:672:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxp->codes); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:724:49: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| ils->code_size == ivf->code_size)); | |
| ~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:752:13: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR ((*ids)[i]); | |
| ^~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:767:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (buf); | |
| ^~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:774:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (il.ids); | |
| ^~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:776:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (il.vecs); | |
| ^~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:790:5: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (buf); | |
| ^~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:814:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxf->xb); | |
| ^~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:815:45: warning: comparison of integers of different signs: 'std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >::size_type' (aka 'unsigned long') and 'long long' [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (idxf->xb.size() == idxf->ntotal * idxf->code_size); | |
| ~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| impl/index_read.cpp:843:9: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare] | |
| READVECTOR (idxmap->id_map); | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:75:9: note: expanded from macro 'READVECTOR' | |
| READANDCHECK ((vec).data (), size); \ | |
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| impl/index_read.cpp:62:36: note: expanded from macro 'READANDCHECK' | |
| FAISS_THROW_IF_NOT_FMT(ret == (n), \ | |
| ~~~ ^ ~ | |
| ./faiss/impl/FaissAssert.h:90:11: note: expanded from macro 'FAISS_THROW_IF_NOT_FMT' | |
| if (!(X)) { \ | |
| ^ | |
| 55 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/index_write.cpp -o impl/index_write.o | |
| In file included from impl/index_write.cpp:35: | |
| In file included from ./faiss/MetaIndexes.h:16: | |
| In file included from ./faiss/IndexShards.h:12: | |
| In file included from ./faiss/impl/ThreadedIndex.h:80: | |
| ./faiss/impl/ThreadedIndex-inl.h:164:48: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterAddIndex(IndexT* index) { | |
| ^ | |
| ./faiss/impl/ThreadedIndex-inl.h:169:51: warning: unused parameter 'index' [-Wunused-parameter] | |
| ThreadedIndex<IndexT>::onAfterRemoveIndex(IndexT* index) { | |
| ^ | |
| 2 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/io.cpp -o impl/io.o | |
| impl/io.cpp:235:9: warning: '~BufferedIOWriter' has a non-throwing exception specification but can still throw [-Wexceptions] | |
| FAISS_THROW_IF_NOT(written > 0); | |
| ^ | |
| ./faiss/impl/FaissAssert.h:77:7: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| FAISS_THROW_FMT("Error: '%s' failed", #X); \ | |
| ^ | |
| ./faiss/impl/FaissAssert.h:67:5: note: expanded from macro 'FAISS_THROW_FMT' | |
| throw faiss::FaissException(__s, __PRETTY_FUNCTION__, __FILE__, __LINE__); \ | |
| ^ | |
| impl/io.cpp:229:19: note: destructor has a implicit non-throwing exception specification | |
| BufferedIOWriter::~BufferedIOWriter() | |
| ^ | |
| 1 warning generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c impl/lattice_Zn.cpp -o impl/lattice_Zn.o | |
| impl/lattice_Zn.cpp:179:19: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::Repeat, std::__1::allocator<faiss::Repeat> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| if (j == repeats.size()) { | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| impl/lattice_Zn.cpp:197:23: warning: comparison of integers of different signs: 'int' and 'std::__1::vector<faiss::Repeat, std::__1::allocator<faiss::Repeat> >::size_type' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < repeats.size(); i++) { | |
| ~ ^ ~~~~~~~~~~~~~~ | |
| impl/lattice_Zn.cpp:287:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/lattice_Zn.cpp:300:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int i = 0; i < n; i++) { | |
| ~ ^ ~ | |
| impl/lattice_Zn.cpp:311:24: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (long i = 0; i < nq; i++) { | |
| ~ ^ ~~ | |
| impl/lattice_Zn.cpp:317:23: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(long i = 0; i < nc; i++) { | |
| ~ ^ ~~ | |
| impl/lattice_Zn.cpp:320:28: warning: comparison of integers of different signs: 'long' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (long j = 0; j < nq; j++) { | |
| ~ ^ ~~ | |
| impl/lattice_Zn.cpp:566:27: warning: comparison of integers of different signs: 'int' and 'uint64_t' (aka 'unsigned long long') [-Wsign-compare] | |
| for (int i = 0; i < nvi; i++) { | |
| ~ ^ ~~~ | |
| 8 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/Heap.cpp -o utils/Heap.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/WorkerThread.cpp -o utils/WorkerThread.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/distances.cpp -o utils/distances.o | |
| utils/distances.cpp:362:12: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (nx < distance_compute_blas_threshold) { | |
| ~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| utils/distances.cpp:382:12: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (nx < distance_compute_blas_threshold) { | |
| ~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| utils/distances.cpp:695:12: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (nx < distance_compute_blas_threshold) { | |
| ~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| utils/distances.cpp:710:12: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int' [-Wsign-compare] | |
| if (nx < distance_compute_blas_threshold) { | |
| ~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| 4 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/distances_simd.cpp -o utils/distances_simd.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/extra_distances.cpp -o utils/extra_distances.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/hamming.cpp -o utils/hamming.o | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:416:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < d; i += 8) { | |
| ~ ^ ~ | |
| utils/hamming.cpp:419:24: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| int nj = i + 8 <= d ? 8 : d - i; | |
| ~~~~~ ^ ~ | |
| utils/hamming.cpp:494:55: warning: comparison of integers of different signs: 'const int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| FAISS_THROW_IF_NOT (order[i] >= 0 && order[i] < da); | |
| ~~~~~~~~ ^ ~~ | |
| ./faiss/impl/FaissAssert.h:76:11: note: expanded from macro 'FAISS_THROW_IF_NOT' | |
| if (!(X)) { \ | |
| ^ | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:606:9: note: in instantiation of function template specialization 'faiss::hammings_knn_mc<faiss::HammingComputer4>' requested here | |
| hammings_knn_mc<faiss::HammingComputer4>( | |
| ^ | |
| utils/hamming.cpp:347:51: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < csi.counters[b] && nres < k; l++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:613:9: note: in instantiation of function template specialization 'faiss::hammings_knn_mc<faiss::HammingComputer8>' requested here | |
| hammings_knn_mc<faiss::HammingComputer8>( | |
| ^ | |
| utils/hamming.cpp:347:51: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < csi.counters[b] && nres < k; l++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:618:9: note: in instantiation of function template specialization 'faiss::hammings_knn_mc<faiss::HammingComputer16>' requested here | |
| hammings_knn_mc<faiss::HammingComputer16>( | |
| ^ | |
| utils/hamming.cpp:347:51: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < csi.counters[b] && nres < k; l++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:623:9: note: in instantiation of function template specialization 'faiss::hammings_knn_mc<faiss::HammingComputer32>' requested here | |
| hammings_knn_mc<faiss::HammingComputer32>( | |
| ^ | |
| utils/hamming.cpp:347:51: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < csi.counters[b] && nres < k; l++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:629:13: note: in instantiation of function template specialization 'faiss::hammings_knn_mc<faiss::HammingComputerM8>' requested here | |
| hammings_knn_mc<faiss::HammingComputerM8>( | |
| ^ | |
| utils/hamming.cpp:347:51: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < csi.counters[b] && nres < k; l++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:346:42: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int b = 0; b < nBuckets && nres < k; b++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:633:13: note: in instantiation of function template specialization 'faiss::hammings_knn_mc<faiss::HammingComputerDefault>' requested here | |
| hammings_knn_mc<faiss::HammingComputerDefault>( | |
| ^ | |
| utils/hamming.cpp:347:51: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int l = 0; l < csi.counters[b] && nres < k; l++) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:353:17: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| while (nres < k) { | |
| ~~~~ ^ ~ | |
| utils/hamming.cpp:39:21: warning: unused variable 'BLOCKSIZE_QUERY' [-Wunused-const-variable] | |
| static const size_t BLOCKSIZE_QUERY = 8192; | |
| ^ | |
| utils/hamming.cpp:46:22: warning: variable 'hamdis_tab_ham_bytes' is not needed and will not be emitted [-Wunneeded-internal-declaration] | |
| static const uint8_t hamdis_tab_ham_bytes[256] = { | |
| ^ | |
| 25 warnings generated. | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/random.cpp -o utils/random.o | |
| g++ -std=c++11 -DFINTEGER=int -I. -fPIC -m64 -Wno-sign-compare -g -O3 -Wall -Wextra -mpopcnt -msse4 -c utils/utils.cpp -o utils/utils.o | |
| utils/utils.cpp:385:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for(int j = 0; j < d; j++) | |
| ~ ^ ~ | |
| utils/utils.cpp:388:23: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int i = 0; i < d; i++) { | |
| ~ ^ ~ | |
| utils/utils.cpp:607:27: warning: comparison of integers of different signs: 'int64_t' (aka 'long long') and 'size_t' (aka 'unsigned long') [-Wsign-compare] | |
| for (int64_t i = 0; i < n2; i++) | |
| ~ ^ ~~ | |
| 3 warnings generated. | |
| ar r libfaiss.a AutoTune.o Clustering.o DirectMap.o IVFlib.o Index.o Index2Layer.o IndexBinary.o IndexBinaryFlat.o IndexBinaryFromFloat.o IndexBinaryHNSW.o IndexBinaryHash.o IndexBinaryIVF.o IndexFlat.o IndexHNSW.o IndexIVF.o IndexIVFFlat.o IndexIVFPQ.o IndexIVFPQR.o IndexIVFSpectralHash.o IndexLSH.o IndexLattice.o IndexPQ.o IndexPreTransform.o IndexReplicas.o IndexScalarQuantizer.o IndexShards.o InvertedLists.o MatrixStats.o MetaIndexes.o OnDiskInvertedLists.o VectorTransform.o clone_index.o index_factory.o impl/AuxIndexStructures.o impl/FaissException.o impl/HNSW.o impl/PolysemousTraining.o impl/ProductQuantizer.o impl/ScalarQuantizer.o impl/index_read.o impl/index_write.o impl/io.o impl/lattice_Zn.o utils/Heap.o utils/WorkerThread.o utils/distances.o utils/distances_simd.o utils/extra_distances.o utils/hamming.o utils/random.o utils/utils.o | |
| ar: creating archive libfaiss.a | |
| g++ -std=c++11 -dynamiclib -undefined dynamic_lookup -o libfaiss.dylib AutoTune.o Clustering.o DirectMap.o IVFlib.o Index.o Index2Layer.o IndexBinary.o IndexBinaryFlat.o IndexBinaryFromFloat.o IndexBinaryHNSW.o IndexBinaryHash.o IndexBinaryIVF.o IndexFlat.o IndexHNSW.o IndexIVF.o IndexIVFFlat.o IndexIVFPQ.o IndexIVFPQR.o IndexIVFSpectralHash.o IndexLSH.o IndexLattice.o IndexPQ.o IndexPreTransform.o IndexReplicas.o IndexScalarQuantizer.o IndexShards.o InvertedLists.o MatrixStats.o MetaIndexes.o OnDiskInvertedLists.o VectorTransform.o clone_index.o index_factory.o impl/AuxIndexStructures.o impl/FaissException.o impl/HNSW.o impl/PolysemousTraining.o impl/ProductQuantizer.o impl/ScalarQuantizer.o impl/index_read.o impl/index_write.o impl/io.o impl/lattice_Zn.o utils/Heap.o utils/WorkerThread.o utils/distances.o utils/distances_simd.o utils/extra_distances.o utils/hamming.o utils/random.o utils/utils.o -lblas -llapack |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment