September 2024 - Boost - lists.preview.boost.org

[multi] A successor to Boost.MultiArray?
by Andrzej Krzemienski 25 Sep '24

25 Sep '24

Alfredo, Did I get it right that Multi can be considered a superior alternative to Boost.MultiArray? If so, it triggers a couple of points: * Can Boost.MultiArray be upgraded instead? * The same questions, "is it useful at all", apply also to Boost.MultiArray. * Whatever the motivation for using Boost.MultiArray is, it should also be a good motivation for Multi. I read in the Boost.MultiArraydocs that it is a better replacement for vector<vector<...>>. So, maybe a good use case is for simple use cases, where you want to store and perform a simple access to relatively small-sized data sets, where performance is important, but not super-critical, and changing from nested vectors to Multi is already good and sufficient an optimization. As a side note, when comparing Multi with std::mdspan. The latter requires C++23, while the former, only C++17. So, when someone has C++17, mdspan is not an option. BTW, why do you require C++17? Regards, &rzej;

1 0

Re: [boost] [Multi] Proposal
by Alfredo Correa 25 Sep '24

25 Sep '24

> > Date: Sat, 21 Sep 2024 20:10:25 +0300 > From: Artyom Beilis <artyom.beilis(a)gmail.com> > > I do scientific computing with large arrays, and nobody uses OpenCV. > > It would be fair if you had said that it is the de facto standard for > image processing, which I don't do. > > > > Ok... if you haven't used does not mean that it isn't very common > computing library that many developers/designers go by default. > Maybe we don't agree what numeric means, or we just work in different environments. Anyway, I would agree that OpenCV is unquestionably a standard for image processing. > > > Second, Multi is not a numerical library specifically; it is about the > logic and semantics of multidimensional arrays and containers, regardless > of the element type. > > ... > > > See, this is exactly the problem. Why would I need something like that > if I need to go to all the 3rd party libraries to actually use one > efficiently? > The same reason some of use the standard library containers, or ranges, etc, even if they don't "do everything". > cv::Mat is numpy like NDArray with strides, windows, offsets (yes it > supports more than two dimensions). I myself used/written several > Tensor like objects and used (pytorch C++ tensor, dlprimitives > and other objects). It is nothing new, by all means it is the easiest > part of any numerical library. > I don't know how generically OpenCV can treat strides, windows, offsets, etc.; I trust you. Again, this boils down to compare apples with oranges, frameworks vs components. I don't have experience with OpenCV, I have seen code using with OpenCV, it seems it has a lot of features, you can load images, render windows, and do some array computations. It doesn't look like generic code to me, STL can not be used directly, for example (which is fine). I propose that, if you need to read images, and do the standard things that openCV is build for, such image processing, and probably much beyond, by all means use OpenCV. And I propose that if you need to do generic programming with standard algorithms, iterators, and some level of abstraction, use Multi, or something else. If you are not interested in the second (which is fine) then you are not the right audience for the proposed library. > >> > >> 2. While actual ndarry handling is nice, it is basically a tip of an > >> iceberg. You need a decent set of high performance algo combined with > it. > > > I couldn't agree more. The thing that I appreciate about generic programming and programming with components is that it separates data structures and algorithms. And if one does it right, the goal is no loss of efficiency. Of course this requires a lot of work, specially for library developers. > > > > There is a clear separation of concerns here. > > The Multi library deals with the data structure, it uses when it needs > to fulfill its semantics, the best *existing* algorithms it can in > awareness of the datastructure. > > The Multi library doesn't provide algorithms, it uses the algorithms > that are provided to it via different mechanisms. > > > > But if you don't provide algorithms, maybe I'd better take a > library/framework that does. > Exactly, that is the appeal of frameworks. Frameworks are great if they do all that you need and no less. The moment you need to do something that the framework has not contemplated you are totally on your own, without much help. There are plenty of numpy-like arrays around. Usually they are called > tensors... > I agree, and almost all of them are frameworks. I don't think anything works with existing STL algorithms, iterators. If you are not interested in this, this is not for you. > >> > > I agree, promising all linear algebra is infinite work, like > reimplenting MATLAB or Mathematica, but BLAS has a finite number of > functions. > > The philosophy of the BLAS-adaptor in particular (again, an optional > component) is to interface to what BLAS offers and not more. > > It is more of a model how to interface a legacy library using the > features of Multi. > > > But that is exactly what make opencv useful and multi-array like a > fasade with emptiness behind. > This is like saying all the STL containers are just "emptiness behind". In some sense it is true; you need algorithms, that exists separately. I understand your feelings. The emptiness that you feel, the "rest" is the algorithms and adaptors that exists separately from the data structure. There are excellent libraries for that, starting from STL. >> I did breef look into implementation and it seems to be lacking of > >> vectorization (use of intrinsics/vector operators) or have I missed? > > > > > > You missed that this is a generic, not specifically numerical, library. > > > But, you making numpy-like library... You keep bringing up numpy. Some users of the library see the analogy with numpy because of the easy of use, and I appreciate that but I don't mention numerics or numpy in the documentation, except in one or two places with very clear context. If, for you, numpy implies numerics, then you are using the wrong analogy and point of comparison. > otherwise you wouldn't be > interfacing cblas. > Would you feel better about it if I remove the BLAS adaptor? This is a completely optional component. This is to make the library more immediately useful without converting it into a framework. The interface with BLAS is very strictly to be have to use BLAS through the Multi facilities in a functional (immutable) context that is friendly, for example, to STL algorithms that take lambdas. See, if you have been talking about multi-array as advanced > std::vector of generic objects... Ok - but you don't > "Advanced std::vector of generic objects" is a fair scope for the library, thank you. I would say it is *very* advanced version of std::vector, but this is just an opinion I have. I don't understand exactly what is your complain, what do you mean with "but you don't". This is what I say in the introduction: "This library offers array containers and subarrays in arbitrary dimensions with well-behaved value semantics, featuring logical access recursively across dimensions and to elements through indices and iterators." I don't know where you read numerics in there. you direct it to the numeric computations. > I don't direct it to the numerical computation; I clearly say in the introduction that this is not a numerical library. I use build-in types (preferably ints) in the examples for conciseness. I just say that if you want to use it in numerical context, it still should be ok for that. The reason I don't and I won't explicitly rule out numeric applications in the documentation is because in my opinion there are no obstacles to put to use the library in numerical context. The library is in fact used in numerical context by other projects. > The other thing to take into account is that > vectorization/parallelization is still provided by the external algorithms > the library uses internally. > > For example, then dealing with GPU or OpenMP arrays, the library uses > thrust algorithms if they are available, which are parallel. > > > Just for the record there are two levels of parallelization on CPU > level: 1 thread based parallelization, 2nd SIMD level parallelization > like SSE/AVX2/Neon - where you load vectors of 16, 32 bytes of data > and process them together in a single instruction. > These can increase the performance significantly. Yes, I gave the example about thread paralellization, through execution policies, because it is cleaner. SIMD parallelization is more difficult to apply in general because it depends on data to be continuous in at least one dimension, which is only realized by very specific layouts (this is the reason BLAS matrices always have at least one stride = 1). This is not the general case, when you manipulate arrays dynamically. But I agree it still can be applied with some effort. I would do everything I can to offer the possibility of doing SIMD through the library in combination with external algorithms and lift any obstacles to it, if there are any. Having said that, it is not a big concern for the library implementation because 1) it is not numeric specifically, 2) semantic operations in the library, such as assignment or construction do not involve computation. However, if you have a clear idea how to enable SIMD for a particular problem you are free to do it, once again, through specialized algorithms. > > OpenCV isn't 2d only. It support n-D tensors with views. > Ok, I stand corrected then. @Artyom, Can you help me understand how it compare in these aspects that are important for my library? I bet OpenCV will do very well in the comparison. It is a simple checkbox list. - external Deps ? - Arbritary number of dims (e.g. 11 dimensions) - Non-owning view of data (e.g. manipulate view memory provided by others) - Compile-time dim size - Array values (owning data) (e.g. can I put arrays inside a std::list?) - Value semantic (Regular) (can I assign, swap, with expected Stepanov regularity results) - Move semantics (e.g. will this copy data arr2 = std::move(arr1) ?) - const-propagation semantics (e.g. Mat const arr; ... is arr really read-only) - Element initialization (e.g. can the arrays be initialized at declaration e.g. Mat const arr = {1.0, 2.0, ...}) - References w/no-rebinding (e.g. can I name a subblock of an array, e.g. `auto sub = subblock of arr`? does it have reference semantics (no copy)?) - Element access (e.g. how easy is to access a speicif elements, e.g. in 4 dimensions `arr( 3, 4, 5, 6)`) - Partial element access, (e.g. take n-th column or n-th row of a 2D array) - Subarray views (e.g. generate a "view" 2D subblock of a 2D array) - Subarray with lower dim (e.g. generate a "view" nD subblock of a mD array, where n < m). - Subarray w/well def layout (e.g. access the layout of a subblock, if sunblocks can be referred to?) - Recursive subarray (e.g. can sunblocks "views" of subblocks "view" be temporaries) - Custom Alloctors (e.g. thrust::device_allocator, boost::interprocess::allocator) - PMR Alloctors (e.g. use std::pmr::monotonic_memory_resource) - Fancy pointers / references (e.g. use memory not represented by raw pointers, e.g. thrust::device_pointer, boost::interprocess::offset_ptr) - Stride-based Layout (e.g. supports strides layout, element, and can gives this information to low level libraries) - Fortran-ordering (e.g. left-index is the fast index in memory) - Zig-zag / Tiles / Hilbert ordering / (e.g. fancy layouts beyond strides) - Arbitrary layout (e.g. can data be laid out arbitrarily in memory in a user-defined way, not strides, not zig-zag) - Flattening of elements (e.g. any facilities to look at the elements in a flatted way beyond simply giving a pointer to the first element, which will not work for subblocks) - Iterators (e.g. have the array, in any useful sense, .begin and .end?) - Multidimensional iterators (cursors) (e.g. auto h = arr_subarray.home(); h gives access to elements but is light as a pointer) - STL algorithms or Ranges (e.g. would it work with `std::sort`, `std::copy`, `std::reduce`, `std::rotate`, or with any ranges algorithm) - Compatibility with Boost (e.g. put arrays in Boost containers, use Boost Serialization, Boost interprocess, Boost algorithms) - Compatibility with Thrust or GPUs (e.g. can the array elements be in the gpu, and use the array through its interface without segfaulting, or use thrust::device_pointer memory) - Used in production (e.g. major users or industries) > > > > I consider that Eigen, OpenCV, Kokkos, PETSc are frameworks. > > > It reminds me of a comparison of Boost.Beast and a full scale > framework like CppCMS. > When I reviewed beast it was clear that it does not do 10% of what is > expected from something > to make an actually useful web application. > I am not an expert on Boost.Beast, but it looks like you are not the typical audience for some of Boost libraries. The key to me, although not exclusively, is the availability of generic components and generic programming. > While it is nice to have an abstraction - if so either keep it basic > or go full way - you are stuck somewhere > in between std::vector ++ and something like OpenCV. > This is a fair assessment, if you see resemblances with OpenCV is welcomed but accidental, since it is a library that I don't use. Sorry if you are disappointed this library doesn't do (directly at least) things that OpenCV does; the library definitely can do other things that OpenCV can't (and you are not interested in), and even if OpenCV can do them, it will do them with an interface that I is not within the scope of the goals of my library. > > > > I don't fill confident adding an OpenCV column because I don't have > experience with it, but feel free to help me adding a library and answering > the points of each row in the comparison table. > > > I suggest getting some experience with OpenCV. It is a very good > library that already implements what you have (also in a different > way) > I doubt OpenCV implements everything that Multi has. But even if it does, it does it with a different interface that was a priority for my design. (To be fair, Multi doesn't implement everything that OpenCV does either, for sure) > It ain't perfect by any means. But it works, well debugged, understood > and is a widely available library that does the job. > I don't doubt this. I think it is good that both libraries are different, I don't need all the bells and whistles that OpenCV has and it is undeniably a heavy dependency. I don't need rendering images, loading images, or be optimized for element types that OpenCV offers. > >> What is not clear to me is why should I use one over some existing > solution > >> like OpenCV? > > > > > > - Because sometimes your elements are not numerical types. > > > Yeahhh... don't buy it. Sorry :-) > yeah, but I do need a 100x100 array of std::strings. and a 20x10 array of std::tuples. I would love to know if OpenCV can store those. > > > > > - Because sometimes you want to specify your element types as template > parameters not as OpenCV encoded types. > > > To make your code compilation slower and more horrible? Actually > OpenCV supports templated accessors. > This is the perennial discussion between header-only and pre-compiled libraries. I don't have anything to add, the idea is that you pay at compilation for what you use. Feel free to try the library in Godbolt to see the compilation times and the machine code it produces. It is a pity that OpenCV is not in Godbolt to compare both online. Having said that, I would welcome any comparison in timing and usability between the two libraries within or around the scope of what I am proposing. > > > > - Because sometimes you want arbitrary dimensionality (e.g. 2D, 3D, 6D) > to be compile-time. > > > And why it isn't possible with OpenCV > I don't know, is it possible? >From the examples I see online, all OpenCV arrays regardless of dimensionality have all the same type. Maybe I am mistaken. > > > > - Because sometimes you want to apply generic algorithms to your arrays > (STL, std::sort, std::rotate, std::ranges, boost::algorithms, serialization) > > > Yeah... good luck with that in numerical context. But Ok. I use the library in numerical context, I have no problem with that: https://gitlab.com/npneq/inq https://github.com/QMCPACK/qmcpack > In OpenCV > you can just get several pointers and work with them > You can not have it both ways. If you need a pointer and the sizes (and strides), Multi gives you access for that too; and then according to your definition, it would be equally powerful as OpenCV. https://gitlab.com/correaa/boost-multi#legacy-libraries-c-apis > > > > - Because sometimes you want to implement function that are oblivious to > the actual dimension or your array (e.g. simultaneously view a 3D array of > elements as a 2D array of something, for abstraction). > > - Because sometimes you want to control allocations, use fancy pointers, > parameterized memory strategies, polymorphic allocators, > > > OpenCV support custom allocations (actually something I exactly use > right now to monitor memory consumption) > That is great, can you point me to an example? >From what I quickly see online, openCV gives its own allocators. I am not interested in non-standard allocators for this library. It is not clear to me if you can use standard allocators and PMR allocator in OpenCV. Can it take allocators that do not return raw pointer types such as GPU? and if not, what if you allocate a raw pointer with cudaMalloc, how much of the library can you still use? > Once again - be careful what you wish for. Templated allocators are > huge headache to work with in comparison to run-time ones (in real - > non fancy template world that Boost Loves) > It is not a matter of what I wish. The library is not a framework, allocation is something that the user of the library brings in. I don't choose it for them. > > > - Because sometimes you want precise value semantics > > > I'm not sure it is a great idea for huge arrays/matrices. Virtually > ALL tensor libraries have reference semantics for a very good reason. > Sometimes you need it, sometimes you don't. If you don't need, don't make copies, don't pass by value, that is the right thing to do and allowing the option it is a priority of the library. I prevent the library to make copies as much as I can, until the user really means it. > > > > - Because sometimes you want to work with subblocks of an array in the > same way to need you work with the whole array. > > > And this is exactly what view is for... And this is common for any > tensor library. > Great, I would feel bad if I didn't provide this fundamental feature. The next question is whether arrays and subarrays/subblocks/views can be treated in equal footing. > > - Because sometimes you want to give guarantees in the presence of > exceptions (the library doesn't throw exceptions, to be clear). > > Ok this is one of the points I want to discuss here in terms of > design, exceptions and broadcasting. > Lets take an example (numpy - but same works for torch::Tensor) > > a=np.ones(5,10) > b=np.ones(2,5,1) > c=a+b > > It would perform broadcasting to Shape = (2,5,10) - automatically. How > it can be done - you broadcast shapes > of a to 2,5,10 using strides (0,10,1) and broadast b to same shape > using strides (5,1,0) (I hope I have not mistaken in calcs) > Then you can run easily on shape 2,5,10 and do all calculations, fetching > etc. > > Looking into your broadcasting docs - left me with the impression it > does not support anything like this. > What do you mean by "anything like this"? The library doesn't make algebraic assumptions about the arrays of the elements. There is no binary addition + in the library, you can define your own if you want, using well know algorithms or specializations of them. Once you tell me what is your specification and implementation of '+' I can tell you how to use broadcast for your case. If it is a good example I could even add it to the documentation. Note that + implies an algebra, I don't consider it part of the scope of the library. Broadcast instead is part of the library because I consider it a non-algebraic but very powerful array manipulation feature. Broadcast is implemented in the library within a certain design. I think you are disapointed because the broadcast is not "automatic", which is a different issue. > I read this: > > > First, broadcasted arrays are infinite in the broadcasted > dimension; iteration will never reach the end position, and calling > `.size()` is undefined behavior. > > Why? You certainly can iterate over broadcasted dimension... > Yes, you can iterate, that is fine. multi::array<int, 1> A1D = {1, 2, 3}; auto const& A2D = A1D.broadcast(); // A2D = { {1, 2, 3}, {1,2, 3}, {1,2, 3}, ....} assert( A1D[0] == {1, 2, 3} ); assert( A1D[1] == {1, 2, 3} ); ... what is your question? is your question what should A2D.size() return? > Also how do you handle incompatible broadcasting without exception - > for example if b in the example above was of shape (2,5,3) and not > (2,5,1) > The "raw" broadcast operation in the library is an operation that cannot fail. It is how the user of the broadcasted object uses it what can create problems down the road if he doesn't know what he/she is doing. The user may choose algorithms that throw when sizes are incompatible, or just assert or just continue. Who am I to choose for them? (I do it in a certain way in the BLAS adaptor but that is a completely different story). > Exceptions are useful. And claiming that you don't throw ones means > you don't use new... > Exceptions are great, that doesn't mean that every library should be throwing exceptions. And you are completely correct: the library doesn't use `new`. (I couldn't, even if I wanted since the arrays should work in especial memory too). The user of the library provides the allocator, the library itself doesn't throw. At most, it is the allocation (or element assignment) what can throw and I don't have control over that because it is an arbitrary element type and the library will handle it well. > I highly doubt the practicality of the library in the current form. > While generic multi-array can be nice to have, but actually it is > stuck at being little bit more that MultiArray > but too far even from basic numpy. > Thank you for your assessment. I think you don't agree with the scope of the library, which would be fine. May be you also think that the scope of the library is more than what I state, which is something I would like to clarify in some way. l don't think this is a little more than MultiArray, but it depends on the usage and how much you care about certain things. (there is a column in the table that will help you evaluate the differences). Thank you, Alfredo

3 3

Re: [boost] [Multi] Proposal
by Alfredo Correa 25 Sep '24

25 Sep '24

Date: Sun, 22 Sep 2024 17:13:07 +0200 > From: Seth <bugs(a)sehe.nl> > Thanks Sehe for the feedback. I answered Artyom in a separate message in the mailing list. > > On Sat, Sep 21, 2024, at 7:10 PM, Artyom Beilis via Boost wrote: > > > > But if you don't provide algorithms, maybe I'd better take a > > library/framework that does. > Perhaps. > This is the eternal discussion of frameworks vs generic components. > > But, you making numpy-like library... otherwise you wouldn't be > > interfacing cblas. > > A clear case of diyd/diyd ("Damned If You Do, Damned If You Don't"). Of > all the features you're missing here you decry "At least show ways to > interoperate with existing thirdparty libraries". Now, they went and did > that (if I'm not mistaken, clearly marked as an extension that might not > even be part of the proposed library), and you decry that. There's no > winning. > I couldn't have said it better myself. > > It [OpenCV] ain't perfect by any means. But it works, well debugged, > understood > > and is a widely available library that does the job. > > It's also a pretty heavy dependency, especially if you didn't need all the > other stuff, and appears to be an example of an intrusive framework (for > good reason, IFF you need the rest) > Right, comparing a framework with a generic component is a waste of time. One has to look at how things inside and "outside" the framework compare, and how the code scales after that. This takes a lot of time and effort and will keep boiling down to frameworks vs generic component. I will say "you can sort with std::sort a 2D array" and the other person will answer either that a) "he/she doesn't need to do that" or b) that "he/she can ask the developer of the framework to implement .sort_by_row and .sort_by_col`" or c) that "he/she can take the pointer to the data structure and do it himself". It is a never ending argument. > > Exceptions are useful. And claiming that you don't throw ones means > > you don't use new... > > Many things don't require allocation. Meanwhile `new(std::nothrow)` has > existed since c++11. > It is more general than that, the library tries to gives some guarantees for exceptions that happen during allocation or element copy/assignments. The library itself doesn't throw exceptions during these operations, but it handles the ones that the elements operations or allocators produce, if it needs to, Thank you all for you feedback, Alfredo

2 1

Re: [boost] Boost Digest, Vol 7345, Issue 1
by Alfredo Correa 25 Sep '24

25 Sep '24

Hi Artyom, Thank you for you for noticing the proposal and the feedback. > It can be excellent to have something like standard MD arrays like numpy is > today for python, but... > yes, this is one of the goals. > 1. You haven't mentioned even once OpenCV which today is the de-facto > standard for numerical computing in today's C++ world. I do scientific computing with large arrays, and nobody uses OpenCV. It would be fair if you had said that it is the de facto standard for image processing, which I don't do. Second, Multi is not a numerical library specifically; it is about the logic and semantics of multidimensional arrays and containers, regardless of the element type. Having said that, the library should still be very performant with numerical data, and for that, I delegate that responsibility to the algorithms it uses behind the scenes, which are very customizable. Unfortunately, people read "arrays" immediately jump to "numerics" and "linear algebra". >From the introduction "The library's primary concern is with the storage and logic structure of data; it doesn't make algebraic or geometric assumptions about the arrays and their elements. (It is still a good building block for implementing mathematical algorithms, such as representing algebraic dense matrices in the 2D case.) In this sense, it is instead a building block to implement algorithms to represent mathematical operations, specifically on numeric data." > While it isn't > perfect - it actually has similar features in terms of array layout - and > what is more important it has a library of high performance algorithms to > process the data. You must talk at least about interoperability between > cv::Mat and this library > Multi is not an algorithms library, but it carefully plays with existing algorithms and facilitates as much as possible to interface with many numerical libraries. > 2. While actual ndarry handling is nice, it is basically a tip of an > iceberg. You need a decent set of high performance algo combined with it. > There is a clear separation of concerns here. The Multi library deals with the data structure, it uses when it needs to fulfill its semantics, the best *existing* algorithms it can in awareness of the datastructure. The Multi library doesn't provide algorithms, it uses the algorithms that are provided to it via different mechanisms. > > Looks like there is a basic BLAS but the typical library has way-way more > to make it useful. > This is an add-on that is separate from the main library. I cannot even guarantee that it will ship with the proposed version of the library. What do you mean by the "typical library" in "the typical library has way-way more to make it useful"? I agree, promising all linear algebra is infinite work, like reimplenting MATLAB or Mathematica, but BLAS has a finite number of functions. The philosophy of the BLAS-adaptor in particular (again, an optional component) is to interface to what BLAS offers and not more. It is more of a model how to interface a legacy library using the features of Multi. > I looked over the code and didn't find include to cblas... Did I miss > something? Also I see request to link cblas/openblas or so. > Yes, you missed that depending on cblas would tie it the application to cblas, not all BLAS implementations can be used through cblas. BLAS is uses through the ABI directly. (basically I have my own version of the cblas header as an implementation detail). Also the BLAS interface is the same for cuBLAS, which is another story. > I did breef look into implementation and it seems to be lacking of > vectorization (use of intrinsics/vector operators) or have I missed? > You missed that this is a generic, not specifically numerical, library. The other thing to take into account is that vectorization/parallelization is still provided by the external algorithms the library uses internally. For example, then dealing with GPU or OpenMP arrays, the library uses thrust algorithms if they are available, which are parallel. vectorization is use by passing execution policies, or whatever mechanism the underlying algorithms use as long as they conform to a certain syntax. (there are some commits coming regarding the passing of execution policies Remember that I don't use many algorithms internally, only those that are necessary to implement the semantics of the array types, assignment, move assignment, construction and destruction. The rest of the operations generate views mostly, so they don't involve computation or algorithms. For the rest, as a user, you have to use algorithms, and I can help if you find that algorithms do not perform as you expect. > 3. Finally I do want to see comparison with stuff like OpenCV, Eigen and > even uBlas (I know it isn't good) > Multi is for multidimensional arrays, not specifically 2D numerical arrays (i.e. matrices). I would be interested in improving the code if someone claims that operations in these libraries are better performant. I wouldn't want the documentation to be a comparison with so many libraries to which there is just very partial overlap. Specially I don't like to compare with frameworks that lock you in into using their own facilities. I consider that Eigen, OpenCV, Kokkos, PETSc are frameworks. Eigen is listed in one column comparing to other libraries. https://gitlab.com/correaa/boost-multi#appendix-comparison-to-other-array-l… I don't fill confident adding an OpenCV column because I don't have experience with it, but feel free to help me adding a library and answering the points of each row in the comparison table. 4. If you do implement many high performance algorithms this library by any > means shouldn't be header only. > I don't implement any high performance algorithms here, I just give the possibility to interface with them and use them internally when needed to fulfill the semantics of a container. > What is not clear to me is why should I use one over some existing solution > like OpenCV? > - Because sometimes your elements are not numerical types. - Because sometimes you want to specify your element types as template parameters not as OpenCV encoded types. - Because sometimes you want arbitrary dimensionality (e.g. 2D, 3D, 6D) to be compile-time. - Because sometimes you want to apply generic algorithms to your arrays (STL, std::sort, std::rotate, std::ranges, boost::algorithms, serialization) - Because sometimes you want to implement function that are oblivious to the actual dimension or your array (e.g. simultaneously view a 3D array of elements as a 2D array of something, for abstraction). - Because sometimes you want to control allocations, use fancy pointers, parameterized memory strategies, polymorphic allocators, - Because sometimes you want precise value semantics - Because sometimes you want to give guarantees in the presence of exceptions (the library doesn't throw exceptions, to be clear). - Because sometimes you want to work with subblocks of an array in the same way to need you work with the whole array. Thanks, Alfredo

4 7

Re: [boost] [Multi] Proposal
by Alfredo Correa 25 Sep '24

25 Sep '24

> > > > Date: Sun, 22 Sep 2024 17:30:04 +0100 > From: John Maddock <jz.maddock(a)googlemail.com> > To: Seth via Boost <boost(a)lists.boost.org> > > >> But, you making numpy-like library... otherwise you wouldn't be > >> interfacing cblas. > > A clear case of diyd/diyd ("Damned If You Do, Damned If You Don't"). Of > all the features you're missing here you decry "At least show ways to > interoperate with existing thirdparty libraries". Now, they went and did > that (if I'm not mistaken, clearly marked as an extension that might not > even be part of the proposed library), and you decry that. There's no > winning. > > +1, I've only been lurking in this conversation, but it seems to me that > trying to compete with low level and highly optimized BLAS libraries is > a fools errand. > I completely agree, I am not even going to try to include vectorized operations inside this library, even as a specialized cases But I will do anything I can for people to be able to exploit them when possible through algorithms and execution policies. At most what I am doing is to interface with BLAS the best I can with some features that are unique to the library in what personally I think is a fairly original way. (capturing a functional-programming interface). Other *numerical* libraries went that way and that is commendable. Thank all for the feedback, Alfredo

1 0

Asset Stewardship Review
by Arnaud Becheler 23 Sep '24

23 Sep '24

I support the C++ Alliance proposal to transfer assets to it and to form a new Steering Committee. I have been using Boost for almost a decade now for my science project, and had some interactions with its community. - My first interaction with the Boost mailing list was to evaluate whether my small science library might be a suitable proposal. The response was pretty clear: no. Boost was seen as too large, and my project too niche (plus, I assume there might have been some quality concerns as well). While I understood the rationale, it did discourage me from further participation in the mailing list. After all, if my project couldn’t be part of Boost, what was the point of staying engaged and spammed ? This experience might help explain at least one data point in the chart from the Alliance proposal, which highlights the mailing list’s decline in participation. - On the other hand, I was still actively using Boost and seeking a community. I was pleasantly surprised by how welcoming the community was to beginners, especially on the Cpplang Slack channel. As a gay person who enjoys sprinkling my Slack posts with rainbow kitties, I never felt ostracized or discriminated against, nor did I witness any bullying. It seems like the community self-regulates quite well, without an apparent need for the enforcement mechanisms proposed by the Foundation. - More significantly, I only became aware of the Foundation through these proposals. I've never had the chance to interact with any of its members, except for Peter, which makes me a bit skeptical of their motivations. In contrast, members of the C++ Alliance—like Vinnie, Rene, and Joaquin—have been consistently accessible and supportive on the Boost channel of the Cpplang Slack. - The quality of the proposal documents is worth noting: the C++ Alliance’s proposal is highly detailed, well-illustrated, and presents a long-term vision that reignited my enthusiasm for the community. In contrast, the Foundation’s proposal felt more like a brief but reassuring affirmation of the importance of our long-held open-source values, without sparking the same level of excitement. Additionally, members of the C++ Alliance were readily available for real-time discussions and debates about their proposal, whereas members of the Foundation were less/not present and communicative on the platforms I personally use. - I believe in values, principles—and results. I can highlight the success of the C++ Alliance with two personal stories. (i) Recently, a colleague mentioned that Boost was outdated and irrelevant. I disagreed and showed them the new website developed by the C++ Alliance. They quickly changed their mind. (ii) Similarly, a colleague who had switched to Rust was convinced C++ was obsolete due to well-known C++ vs. Rust issues. They even compiled a bullet-point list to persuade others to move away from C++. I showed them the C++ Alliance’s Safe C++ initiative in partnership with Sean Baxter. After reading it, they came back excited, saying the proposal addressed every point on their list and could be a game-changer. Unfortunately, I don’t have comparable stories about the Foundation. - As several reviewers have pointed out, there are shared goals and ideologies at the core of the conflict. The community must embrace these common values and reinforce the collaborative spirit that Boost was built on, ensuring the focus remains on innovation and mutual progress rather than division. Continuing down this path of personal conflict only detracts from the mission, diluting the collective potential of the project. It’s essential that we return to a focus on the project's true objectives—technical excellence, inclusivity, and shared success. By prioritizing cooperation and mutual respect, we can ensure that Boost remains a thriving environment for growth. I personally take home these points from the two proposals: - *Foundation Proposal:* - Uphold core values of the open-source community (openness, collaboration, inclusivity). - Push for immediate inclusivity. - Concerned that financial involvement may compromise the project’s integrity. - Recognizes the importance of not becoming too distanced from the community. - Move slowly, but surely, and freely. - *C++ Alliance Proposal:* - Leverage funding to handle unappealing yet necessary tasks. - Focus on modernizing and appealing to younger developers. - Aim to keep the project relevant and attractive to new talent. - Want to maintain a close relationship with developers. - Move fast and throw money at problems. - *Conclusion:* - Both the C++ Alliance and the Foundation share aligned values but focus on different approaches. - They are complementary, addressing different aspects of the same mission. - Their coexistence can provide a balance, acting as counterweights to maintain both ethical standards and practical sustainability. - Transferring assets to the C++ Alliance would enable them to fulfill their part of the mission more quickly. I don't believe it would impede the Foundation's ability to achieve their goals. - The next question for the community is: how can we support the Foundation in return? For example, a reasonably-sized data science project to collect insights on inclusivity and diversity within the Boost community could help them shape future initiatives around the values they prioritize, and would benefit the entire community. Thank you once again for giving us the chance to review these great documents and visions, and for the hard work from all sides that has allowed me to develop my little science project while standing on the towering shoulders of giants ;) Best, Arno

4 3

CODE_OF_CONDUCT.adoc
by Vinnie Falco 23 Sep '24

23 Sep '24

The subject of a code of conduct has come up a few times, and I think it is worth having a discussion. I hope that everyone will find the following statements uncontroversial: 1. Social spaces have rules, either stated or implied 2. Rules need to state clearly what is allowed and what is disallowed, so that people who may be interested in joining can determine if the culture is the right fit. 3. Rules need to be enforced 4. The Boost mailing lists already have rules 5. The rules for the mailing list are outdated 6. The rules for the mailing list are not particularly visible There is value in refreshing the rules for the Boost mailing list, which are currently described here: https://www.boost.org/community/policy.html I think we should do the following: * Update the rules to be relevant for 2024 * Make the rules visible on the sign-up and administration page for the mailing lists (at https://lists.boost.org) * Consider renaming the rules to something other than "Boost Discussion Policy" * Send a periodic announcement to the mailing lists reminding everyone of the rules. These could be timed to coincide with the releases (three times per year) The community needs to discuss the things above and come to a consensus. And we need to make a final decision on what the changes will look like given the feedback. I don't know that the review process is right for this, because it will likely be an iterative process where we all work on a "shared document" to make edits. The nice thing is that we don't need to wait for the outcome of the Boost Asset Stewardship review to do this, because the content of the website and mailing lists is not controlled by the Boost Foundation, the C++ Alliance, or the proposed Steering Committee. And even before the need to decide which revision of the updated rules will be accepted by the project, discussion can take place with no governing body. There is one hiccup though. Where do we discuss this? The mailing list is one possibility. However, anyone who joins the mailing list late, or is not a member of the mailing list, has the problem that the visibility of the discussion is not very great. They would have to use the archives, and the archives are not very pleasant. One cannot see the entire discussion as a single page. And if someone changes the subject, then new related threads of conversation become more difficult to find. And at the end of the day, our workflow requires GitHub issues to triage and assign work items to staff. Therefore, here is a GitHub issue for this. Everyone can feel free to participate in a discussion there. Alternatively, if you feel that the mailing list is a better place, then reply to this post and have a discussion here. There might be two discussions. Or one. Or none (hopefully not). And when we are done we can compare the pros and cons of GItHub issues versus the mailing list. There could be value here. This is the issue: https://github.com/boostorg/website-v2/issues/1269 What do you think? Thanks

3 4

Asset Stewardship Review
by Adam C Getchell 23 Sep '24

23 Sep '24

I support the C++ Alliance proposal to transfer assets and form a new Steering Committee. I’ve been a downstream user of Boost for more than a decade for my research project, and joined the mailing list to get help on using the project effectively. My initial interactions were to sort out build errors, which were mostly resolved with the adoption of vcpkg (after trying biicode and then Conan) and the work on making Boost compatible with CMake. I have appreciated the C++ Alliance’s sponsorship of tools such as the Slack workspace and CI, and I believe this is necessary to ensure progress. I also learned a lot reading the documentation and code of Louis Dionne’s Boost.Hana and Vinnie Falco’s Boost.Beast. As a side note, my research involves writing low-level simulations of the universe, and unfortunately the various memory errors and other bugs have convinced me to go reluctantly down the path of using Rust to write low-level memory-safe abstractions that I can count on to run for months at a time without segfaults or other issues that compromise the validity of the data. Thus, Circle and the recent Safe C++ proposal are very interesting to me, and if they are ever adopted I might back port them to my current codebase. However, this probably won’t be effective until the libraries I depend on make similar efforts. By then, I will probably have everything I need written in Rust. -- Adam Getchell https://adamgetchell.org <https://adamgetchell.org/>

1 0

Boost.LEAF in Embedded Systems (CppCon)
by Vinnie Falco 23 Sep '24

23 Sep '24

At CppCon 2024 the C++ Alliance sponsored a program to interview conference goers about Boost-related topics. This is the first video in the series: Boost.LEAF in Embedded Systems: Insights from Ex-Google Engineer Khalil Estelle at CppCon https://www.youtube.com/shorts/BksBxnTLltY Enjoy! Thanks

1 0

Boost Asset Stewardship Review begins today (3rd Sept)
by Glen Fernandes 22 Sep '24

22 Sep '24

Dear Boost community, The Boost Asset Stewardship Review begins today, 3rd September and ends on 22nd September. For reference, the review schedule is: https://www.boost.org/community/review_schedule.html The submission which initiated the review is the following proposal from the C++ Alliance: https://cppalliance.org/pdf/Fiscal-Sponsorship-Proposal.pdf It proposes a Fiscal Sponsorship which: 1) is a legal agreement where the C++ Alliance holds assets on behalf of the Boost project. It proposes a newly formed (steering) committee that would be composed of Boost developer community members that would determine how the assets are used. 2) donates the assets that it funds to the Boost project (domains, hosting, etc.) The "Boost developer community" here refers to: - Boost library authors - Boost library contributors - Boost release managers For a high level overview of these terms (which I needed) see the following email with definitions: https://lists.boost.org/Archives/boost/2024/09/257579.php The Boost Foundation asks the Boost developer community to consider the following alternative: https://docs.google.com/document/d/1XFt7Bh71e4_uE0iK4jifhR__P0iG5_c1cDfBsMj… The Boost Foundation proposal presents a path forward where it continues to be the steward the assets in question, but offers a change in how these are managed. The assets here refer to the following: - The boost.org domain - Website hosting - Mailing lists - Downloads storage and CDN - Drone CI Currently, the Boost Foundation owns and pays for the following: - Website hosting - Mailing lists The C++ Alliance pays and manages for the following: - The Drone CI - The CDN for the downloads - The download archive - Technical assistance and support for the Boost release process - Backup domain names (in case boost.org expires) - Hosting and downloads for the new website prototype (boost.io) The boost.org domain is absent from both lists above: The Boost Foundation technically does not own it yet. The domain was owned by Beman and he had the credentials. The Boost Foundation is working with Beman's widow and the Dawes Estate to transfer ownership to it. For reference, see Kristen's email: https://lists.boost.org/Archives/boost/2024/08/257563.php Note that the content of the current boost.org site and the new boost.io website is still the province of the Boost developer community. To be clear, the review is not about deciding governance over Boost C++ library development. That remains in the hands of the Boost developer community. Please send all reviews to the Boost developer mailing list. If you do not want to create an account, you can email me at glenfe -at- boost.org with your review and I will post it to the list for you. Include "Asset Stewardship Review" or "Asset Stewardship" in your email subject. In your review do disclose any affiliation to either the C++ Alliance or Boost Foundation groups. Please state any connection you have to Boost (developer, user, package manager etc.) Thank you, Glen

15 26