react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/benchmarks/competition/llvm/ConvertUTF.h

@@ -0,0 +1,293 @@
+/*===--- ConvertUTF.h - Universal Character Names conversions ---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *==------------------------------------------------------------------------==*/
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ *
+ * Disclaimer
+ *
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ *
+ * Limitations on Rights to Redistribute This Code
+ *
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+    Conversions between UTF32, UTF-16, and UTF-8.  Header file.
+    Several funtions are included here, forming a complete set of
+    conversions between the three formats.  UTF-7 is not included
+    here, but is handled in a separate source file.
+    Each of these routines takes pointers to input buffers and output
+    buffers.  The input buffers are const.
+    Each routine converts the text between *sourceStart and sourceEnd,
+    putting the result into the buffer between *targetStart and
+    targetEnd. Note: the end pointers are *after* the last item: e.g.
+    *(sourceEnd - 1) is the last item.
+    The return result indicates whether the conversion was successful,
+    and if not, whether the problem was in the source or target buffers.
+    (Only the first encountered problem is indicated.)
+    After the conversion, *sourceStart and *targetStart are both
+    updated to point to the end of last text successfully converted in
+    the respective buffers.
+    Input parameters:
+        sourceStart - pointer to a pointer to the source buffer.
+                The contents of this are modified on return so that
+                it points at the next thing to be converted.
+        targetStart - similarly, pointer to pointer to the target buffer.
+        sourceEnd, targetEnd - respectively pointers to the ends of the
+                two buffers, for overflow checking only.
+    These conversion functions take a ConversionFlags argument. When this
+    flag is set to strict, both irregular sequences and isolated surrogates
+    will cause an error.  When the flag is set to lenient, both irregular
+    sequences and isolated surrogates are converted.
+    Whether the flag is strict or lenient, all illegal sequences will cause
+    an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
+    or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
+    must check for illegal sequences.
+    When the flag is set to lenient, characters over 0x10FFFF are converted
+    to the replacement character; otherwise (when the flag is set to strict)
+    they constitute an error.
+    Output parameters:
+        The value "sourceIllegal" is returned from some routines if the input
+        sequence is malformed.  When "sourceIllegal" is returned, the source
+        value will point to the illegal value that caused the problem. E.g.,
+        in UTF-8 when a sequence is malformed, it points to the start of the
+        malformed sequence.
+    Author: Mark E. Davis, 1994.
+    Rev History: Rick McGowan, fixes & updates May 2001.
+         Fixes & updates, Sept 2001.
+------------------------------------------------------------------------ */
+
+#ifndef LLVM_SUPPORT_CONVERTUTF_H
+#define LLVM_SUPPORT_CONVERTUTF_H
+
+#include <cstddef>
+#include <string>
+#include <system_error>
+
+// Wrap everything in namespace llvm so that programs can link with llvm and
+// their own version of the unicode libraries.
+
+namespace llvm {
+
+/* ---------------------------------------------------------------------
+    The following 4 definitions are compiler-specific.
+    The C standard does not guarantee that wchar_t has at least
+    16 bits, so wchar_t is no less portable than unsigned short!
+    All should be unsigned values to avoid sign extension during
+    bit mask & shift operations.
+------------------------------------------------------------------------ */
+
+typedef unsigned int    UTF32;  /* at least 32 bits */
+typedef unsigned short  UTF16;  /* at least 16 bits */
+typedef unsigned char   UTF8;   /* typically 8 bits */
+typedef unsigned char   Boolean; /* 0 or 1 */
+
+/* Some fundamental constants */
+#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
+#define UNI_MAX_BMP (UTF32)0x0000FFFF
+#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
+#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
+
+#define UNI_MAX_UTF8_BYTES_PER_CODE_POINT 4
+
+#define UNI_UTF16_BYTE_ORDER_MARK_NATIVE  0xFEFF
+#define UNI_UTF16_BYTE_ORDER_MARK_SWAPPED 0xFFFE
+
+typedef enum {
+  conversionOK,           /* conversion successful */
+  sourceExhausted,        /* partial character in source, but hit end */
+  targetExhausted,        /* insuff. room in target for conversion */
+  sourceIllegal           /* source sequence is illegal/malformed */
+} ConversionResult;
+
+typedef enum {
+  strictConversion = 0,
+  lenientConversion
+} ConversionFlags;
+
+ConversionResult ConvertUTF8toUTF16 (
+  const UTF8** sourceStart, const UTF8* sourceEnd,
+  UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
+
+/**
+ * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
+ * incomplete code unit sequence, returns \c sourceExhausted.
+ */
+ConversionResult ConvertUTF8toUTF32Partial(
+  const UTF8** sourceStart, const UTF8* sourceEnd,
+  UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+/**
+ * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
+ * incomplete code unit sequence, returns \c sourceIllegal.
+ */
+ConversionResult ConvertUTF8toUTF32(
+  const UTF8** sourceStart, const UTF8* sourceEnd,
+  UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF16toUTF8 (
+  const UTF16** sourceStart, const UTF16* sourceEnd,
+  UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF8 (
+  const UTF32** sourceStart, const UTF32* sourceEnd,
+  UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF16toUTF32 (
+  const UTF16** sourceStart, const UTF16* sourceEnd,
+  UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF16 (
+  const UTF32** sourceStart, const UTF32* sourceEnd,
+  UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
+
+Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+
+Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
+
+unsigned getNumBytesForUTF8(UTF8 firstByte);
+
+/*************************************************************************/
+/* Below are LLVM-specific wrappers of the functions above. */
+
+template <typename T> class ArrayRef;
+template <typename T> class SmallVectorImpl;
+class StringRef;
+
+/**
+ * Convert an UTF8 StringRef to UTF8, UTF16, or UTF32 depending on
+ * WideCharWidth. The converted data is written to ResultPtr, which needs to
+ * point to at least WideCharWidth * (Source.Size() + 1) bytes. On success,
+ * ResultPtr will point one after the end of the copied string. On failure,
+ * ResultPtr will not be changed, and ErrorPtr will be set to the location of
+ * the first character which could not be converted.
+ * \return true on success.
+ */
+bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
+                       char *&ResultPtr, const UTF8 *&ErrorPtr);
+
+/**
+* Converts a UTF-8 StringRef to a std::wstring.
+* \return true on success.
+*/
+bool ConvertUTF8toWide(llvm::StringRef Source, std::wstring &Result);
+
+/**
+* Converts a UTF-8 C-string to a std::wstring.
+* \return true on success.
+*/
+bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
+
+/**
+* Converts a std::wstring to a UTF-8 encoded std::string.
+* \return true on success.
+*/
+bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
+
+
+/**
+ * Convert an Unicode code point to UTF8 sequence.
+ *
+ * \param Source a Unicode code point.
+ * \param [in,out] ResultPtr pointer to the output buffer, needs to be at least
+ * \c UNI_MAX_UTF8_BYTES_PER_CODE_POINT bytes.  On success \c ResultPtr is
+ * updated one past end of the converted sequence.
+ *
+ * \returns true on success.
+ */
+bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr);
+
+/**
+ * Convert the first UTF8 sequence in the given source buffer to a UTF32
+ * code point.
+ *
+ * \param [in,out] source A pointer to the source buffer. If the conversion
+ * succeeds, this pointer will be updated to point to the byte just past the
+ * end of the converted sequence.
+ * \param sourceEnd A pointer just past the end of the source buffer.
+ * \param [out] target The converted code
+ * \param flags Whether the conversion is strict or lenient.
+ *
+ * \returns conversionOK on success
+ *
+ * \sa ConvertUTF8toUTF32
+ */
+inline ConversionResult convertUTF8Sequence(const UTF8 **source,
+                                            const UTF8 *sourceEnd,
+                                            UTF32 *target,
+                                            ConversionFlags flags) {
+  if (*source == sourceEnd)
+    return sourceExhausted;
+  unsigned size = getNumBytesForUTF8(**source);
+  if ((ptrdiff_t)size > sourceEnd - *source)
+    return sourceExhausted;
+  return ConvertUTF8toUTF32(source, *source + size, &target, target + 1, flags);
+}
+
+/**
+ * Returns true if a blob of text starts with a UTF-16 big or little endian byte
+ * order mark.
+ */
+bool hasUTF16ByteOrderMark(ArrayRef<char> SrcBytes);
+
+/**
+ * Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
+ *
+ * \param [in] SrcBytes A buffer of what is assumed to be UTF-16 encoded text.
+ * \param [out] Out Converted UTF-8 is stored here on success.
+ * \returns true on success
+ */
+bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
+
+/**
+* Converts a UTF16 string into a UTF8 std::string.
+*
+* \param [in] Src A buffer of UTF-16 encoded text.
+* \param [out] Out Converted UTF-8 is stored here on success.
+* \returns true on success
+*/
+bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);
+
+/**
+ * Converts a UTF-8 string into a UTF-16 string with native endianness.
+ *
+ * \returns true on success
+ */
+bool convertUTF8ToUTF16String(StringRef SrcUTF8,
+                              SmallVectorImpl<UTF16> &DstUTF16);
+
+#if defined(_WIN32)
+namespace sys {
+namespace windows {
+std::error_code UTF8ToUTF16(StringRef utf8, SmallVectorImpl<wchar_t> &utf16);
+/// Convert to UTF16 from the current code page used in the system
+std::error_code CurCPToUTF16(StringRef utf8, SmallVectorImpl<wchar_t> &utf16);
+std::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len,
+                            SmallVectorImpl<char> &utf8);
+/// Convert from UTF16 to the current code page used in the system
+std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len,
+                             SmallVectorImpl<char> &utf8);
+} // namespace windows
+} // namespace sys
+#endif
+
+} /* end namespace llvm */
+
+#endif

package/deps/simdutf/benchmarks/competition/u8u16/COPYRIGHT

@@ -0,0 +1,8 @@
+Copyright (C) 2007 International Characters Inc.
+   Licensed to the public under the Open Software License version 3.0. 
+   Patents pending in Canada, the United States, and other countries.
+   International Characters is a trademark of International Characters Inc.
+   Commercial software licenses are also available.
+         Contact info@international-characters.com.
+   For further information see www.international-characters.com.
+

package/deps/simdutf/benchmarks/competition/u8u16/Makefile

@@ -0,0 +1,44 @@
+CC= g++ $(CFLAGS)
+CFLAGS= -O3 -DBUFFER_PROFILING
+OS = $(shell uname)
+ICONV_FLAGS=
+ifeq ($(OS),Darwin)
+	ICONV_FLAGS=-liconv
+endif
+
+u8u16_64:	u8u16_p4.c config/p4_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h
+	$(CC) -o u8u16_64 u8u16_p4.c -march=nocona -m64
+
+u8u16_64_noopt:	u8u16_p4.c config/p4_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h
+	$(CC) -o u8u16_64_noopt u8u16_p4.c -march=nocona -m64 -DNO_OPTIMIZATION
+
+u8u16_p4:	u8u16_p4.c config/p4_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h
+	$(CC) -o u8u16_p4 u8u16_p4.c -march=pentium4
+
+u8u16_p4_noopt:	u8u16_p4.c config/p4_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h
+	$(CC) -o u8u16_p4_noopt u8u16_p4.c -march=pentium4 -DNO_OPTIMIZATION
+
+u8u16_ssse3:	u8u16_p4.c config/p4_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h
+	$(CC) -o u8u16_ssse3 u8u16_ssse3.c -march=core2
+
+x8x16_p4:	x8x16_p4.c config/p4_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h \
+		src/x8x16.c src/xmldecl.h src/xmldecl.c src/bytelex.h src/multiliteral.h
+	$(CC) -o x8x16_p4 x8x16_p4.c -march=pentium4
+
+u8u16_p4_ideal:	u8u16_p4_ideal.c config/p4_ideal_config.h src/u8u16.c src/libu8u16.c lib/sse_simd.h
+	$(CC) -o u8u16_p4_ideal u8u16_p4_ideal.c -march=pentium4
+
+u8u16_g4:	u8u16_g4.c config/g4_config.h src/u8u16.c src/libu8u16.c lib/altivec_simd.h
+	$(CC) -o u8u16_g4 u8u16_g4.c -maltivec -faltivec
+
+u8u16_mmx:	u8u16_mmx.c config/mmx_config.h src/u8u16.c src/libu8u16.c \
+                lib/mmx_simd.h lib/mmx_simd_basic.h lib/mmx_simd_built_in.h lib/mmx_simd_modified.h
+	$(CC) -o u8u16_mmx u8u16_mmx.c -march=pentium-mmx
+
+iconv_u8u16:	iconv_u8u16.c src/u8u16.c src/libu8u16.c
+	$(CC) -o  iconv_u8u16 iconv_u8u16.c $(ICONV_FLAGS)
+	
+clean:
+	rm -f u8u16_64 u8u16_p4 x8x16_p4 u8u16_p4_ideal u8u16_g4 u8u16_mmx iconv_u8u16
+
+

package/deps/simdutf/benchmarks/competition/u8u16/OSL3.0.txt

@@ -0,0 +1,169 @@
+Open Software License ("OSL") v. 3.0
+
+This Open Software License (the "License") applies to any original work of
+authorship (the "Original Work") whose owner (the "Licensor") has placed the
+following licensing notice adjacent to the copyright notice for the Original
+Work:
+
+Licensed under the Open Software License version 3.0
+
+1) Grant of Copyright License. Licensor grants You a worldwide, royalty-free,
+non-exclusive, sublicensable license, for the duration of the copyright, to do
+the following:
+
+a) to reproduce the Original Work in copies, either alone or as part of a
+collective work;
+
+b) to translate, adapt, alter, transform, modify, or arrange the Original Work,
+thereby creating derivative works ("Derivative Works") based upon the Original
+Work;
+
+c) to distribute or communicate copies of the Original Work and Derivative Works
+to the public, with the proviso that copies of Original Work or Derivative Works
+that You distribute or communicate shall be licensed under this Open Software
+License;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor grants You a worldwide, royalty-free,
+non-exclusive, sublicensable license, under patent claims owned or controlled by
+the Licensor that are embodied in the Original Work as furnished by the
+Licensor, for the duration of the patents, to make, use, sell, offer for sale,
+have made, and import the Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the preferred form
+of the Original Work for making modifications to it and all available
+documentation describing how to modify the Original Work. Licensor agrees to
+provide a machine-readable copy of the Source Code of the Original Work along
+with each copy of the Original Work that Licensor distributes. Licensor reserves
+the right to satisfy this obligation by placing a machine-readable copy of the
+Source Code in an information repository reasonably calculated to permit
+inexpensive and convenient access by You for as long as Licensor continues to
+distribute the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the names
+of any contributors to the Original Work, nor any of their trademarks or service
+marks, may be used to endorse or promote products derived from this Original
+Work without express prior permission of the Licensor. Except as expressly
+stated herein, nothing in this License grants any license to Licensor's
+trademarks, copyrights, patents, trade secrets or any other intellectual
+property. No patent license is granted to make, use, sell, offer for sale, have
+made, or import embodiments of any patent claims other than the licensed claims
+defined in Section 2. No license is granted to the trademarks of Licensor even
+if such marks are included in the Original Work. Nothing in this License shall
+be interpreted to prohibit Licensor from licensing under terms different from
+this License any Original Work that Licensor otherwise would have a right to
+license.
+
+5) External Deployment. The term "External Deployment" means the use,
+distribution, or communication of the Original Work or Derivative Works in any
+way such that the Original Work or Derivative Works may be used by anyone other
+than You, whether those works are distributed or communicated to those persons
+or made available as an application intended for use over a network. As an
+express condition for the grants of license hereunder, You must treat any
+External Deployment by You of the Original Work or a Derivative Work as a
+distribution under section 1(c).
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative
+Works that You create, all copyright, patent, or trademark notices from the
+Source Code of the Original Work, as well as any notices of licensing and any
+descriptive text identified therein as an "Attribution Notice." You must cause
+the Source Code for any Derivative Works that You create to carry a prominent
+Attribution Notice reasonably calculated to inform recipients that You have
+modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the
+copyright in and to the Original Work and the patent rights granted herein by
+Licensor are owned by the Licensor or are sublicensed to You under the terms of
+this License with the permission of the contributor(s) of those copyrights and
+patent rights. Except as expressly stated in the immediately preceding sentence,
+the Original Work is provided under this License on an "AS IS" BASIS and WITHOUT
+WARRANTY, either express or implied, including, without limitation, the
+warranties of non-infringement, merchantability or fitness for a particular
+purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU.
+This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No
+license to the Original Work is granted by this License except under this
+disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory,
+whether in tort (including negligence), contract, or otherwise, shall the
+Licensor be liable to anyone for any indirect, special, incidental, or
+consequential damages of any character arising as a result of this License or
+the use of the Original Work including, without limitation, damages for loss of
+goodwill, work stoppage, computer failure or malfunction, or any and all other
+commercial damages or losses. This limitation of liability shall not apply to
+the extent applicable law prohibits such limitation.
+
+9) Acceptance and Termination. If, at any time, You expressly assented to this
+License, that assent indicates your clear and irrevocable acceptance of this
+License and all of its terms and conditions. If You distribute or communicate
+copies of the Original Work or a Derivative Work, You must make a reasonable
+effort under the circumstances to obtain the express assent of recipients to the
+terms of this License. This License conditions your rights to undertake the
+activities listed in Section 1, including your right to create Derivative Works
+based upon the Original Work, and doing so without honoring these terms and
+conditions is prohibited by copyright law and international treaty. Nothing in
+this License is intended to affect copyright exceptions and limitations
+(including "fair use" or "fair dealing"). This License shall terminate
+immediately and You may no longer exercise any of the rights granted to You by
+this License upon your failure to honor the conditions in Section 1(c).
+
+10) Termination for Patent Action. This License shall terminate automatically
+and You may no longer exercise any of the rights granted to You by this License
+as of the date You commence an action, including a cross-claim or counterclaim,
+against Licensor or any licensee alleging that the Original Work infringes a
+patent. This termination provision shall not apply for an action alleging patent
+infringement by combinations of the Original Work with other software or
+hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
+License may be brought only in the courts of a jurisdiction wherein the Licensor
+resides or in which Licensor conducts its primary business, and under the laws
+of that jurisdiction excluding its conflict-of-law provisions. The application
+of the United Nations Convention on Contracts for the International Sale of
+Goods is expressly excluded. Any use of the Original Work outside the scope of
+this License or after its termination shall be subject to the requirements and
+penalties of copyright or patent law in the appropriate jurisdiction. This
+section shall survive the termination of this License.
+
+12) Attorneys' Fees. In any action to enforce the terms of this License or
+seeking damages relating thereto, the prevailing party shall be entitled to
+recover its costs and expenses, including, without limitation, reasonable
+attorneys' fees and costs incurred in connection with such action, including any
+appeal of such action. This section shall survive the termination of this
+License.
+
+13) Miscellaneous. If any provision of this License is held to be unenforceable,
+such provision shall be reformed only to the extent necessary to make it
+enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License, whether
+in upper or lower case, means an individual or a legal entity exercising rights
+under, and complying with all of the terms of, this License. For legal entities,
+"You" includes any entity that controls, is controlled by, or is under common
+control with you. For purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such entity,
+whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or
+more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise
+restricted or conditioned by this License or by law, and Licensor promises not
+to interfere with or be responsible for such uses by You.
+
+16) Modification of This License. This License is Copyright (c) 2005 Lawrence
+Rosen. Permission is granted to copy, distribute, or communicate this License
+without modification. Nothing in this License permits You to modify this License
+as applied to the Original Work or to Derivative Works. However, You may modify
+the text of this License and copy, distribute or communicate your modified
+version (the "Modified License") and apply it to other original works of
+authorship subject to the following conditions: (i) You may not indicate in any
+way that your Modified License is the "Open Software License" or "OSL" and you
+may not use those names in the name of your Modified License; (ii) You must
+replace the notice specified in the first paragraph above with the notice
+"Licensed under <insert your license name here>" or with a notice of your own
+that is not confusingly similar to the notice in this License; and (iii) You may
+not claim that your original works are open source software unless your Modified
+License has been approved by Open Source Initiative (OSI) and You comply with
+its license review and certification process.

package/deps/simdutf/benchmarks/competition/u8u16/Profiling/BOM_Profiler.h

@@ -0,0 +1,148 @@
+/*
+    BOM_Profiler.h - Binary Order of Magnitude Execution Time Profiler 
+    Copyright (C) 2010  Robert D. Cameron and Dan Lin
+    Version 0.4
+    Licensed to the general public under Academic Free License version 3.0
+
+BOM_Profiler provides a lightweight multiplatform execution time profiling
+utility based on processor cycle counters.  It uses a binary logarithmic
+histogram technique that is useful in both highlighting patterns of 
+cycle time distributions as well as identifing outliers in timing events
+due to interruptions for operating system services.
+
+In essence, BOM profiler is designed to collect statistics over a number
+of repetitions of particular timed events.  Statistics are gathered in the
+form of a logarithmic histogram of cycle times for processing a fixed number 
+of elements between calls to start_BOM_interval and end_BOM_interval.  
+For example, an interval may correspond to processing 1024 single-byte
+elements by a particular routine.
+
+A timer t is created and initialized by a call to t = init_BOM_timer().  
+Given a timer t, start_BOM_interval(t) initiates an interval measurement 
+which completes with end_BOM_interval(t, n), where n is the number of 
+elements processed.  
+
+dump_BOM_table(t) prints out a rudimentary histogram of the recorded
+intervals for a particular timer.  
+
+Although the basic concept of BOM_Profiler is architecture independent,
+processor-dependent routines for accessing time-stamp counters and
+determining the binary order of magnitude are included through external
+files.
+
+
+*/
+
+#ifndef BOM_Profiler_H
+#define BOM_Profiler_H
+
+
+#include "i386_timer.h"
+
+#define BIT_COUNT 64
+#define MAX_TIMER_ENTRIES (1<<18)
+#define TIMER_SCALE_FACTOR 1000
+
+struct BOM_Table {
+  // current timing interval information
+  int timer_on;
+  int full;
+  timestamp_t interval_start[MAX_TIMER_ENTRIES];
+  timestamp_t interval_end[MAX_TIMER_ENTRIES];
+  unsigned int interval_elems[MAX_TIMER_ENTRIES];  
+  unsigned int current_entry;
+};
+
+typedef struct BOM_Table BOM_Table;
+
+BOM_Table * init_BOM_timer () {
+  BOM_Table * timer_table = (BOM_Table *) malloc(sizeof(BOM_Table));
+  if (!timer_table) {
+    printf("Couldn't initialize BOM timer.\n");
+    exit(-1);
+  }
+  timer_table -> current_entry = 0;
+  timer_table -> full = 0;
+  timer_table -> timer_on = 0;
+  return timer_table;
+}
+
+
+static inline void start_BOM_interval(BOM_Table * timer_table) {
+  timer_table->timer_on = 1;
+  timer_table->interval_start[timer_table->current_entry] = read_cycle_counter();
+}
+
+static inline void end_BOM_interval(BOM_Table * timer_table, unsigned int elems) {
+  if (timer_table->timer_on) {
+    timer_table->interval_end[timer_table->current_entry] = read_cycle_counter();
+    timer_table->interval_elems[timer_table->current_entry] = elems;
+    timer_table->current_entry++;
+    if(timer_table->current_entry >= MAX_TIMER_ENTRIES) {
+      timer_table->full=1;
+      timer_table->current_entry=0;
+    }
+    timer_table->timer_on = 0;
+  }
+  else
+  	fprintf(stderr,"Time interval end without a start!\n"); 
+}
+
+void dump_BOM_table(BOM_Table * timer_table) {
+  // an array of counts and timings per binary order of magnitude
+  int BOM_count[BIT_COUNT];
+  unsigned int BOM_elems[BIT_COUNT];  
+  timestamp_t BOM_total_time[BIT_COUNT];
+
+  int BOM, b;
+  int this_count;
+  int cum_count = 0;
+  unsigned int entry = 0;
+  unsigned int total_entries;
+  unsigned int this_elems = 0;
+  unsigned int cum_elems = 0;
+  timestamp_t this_time;
+  timestamp_t cum_time = 0ULL;
+  timestamp_t this_avg;
+  timestamp_t cum_avg;
+  timestamp_t accumulated_cycles;  
+
+  for (b = 0; b < BIT_COUNT; b++) {
+	BOM_count[b] = 0;
+	BOM_elems[b] = 0;
+	BOM_total_time[b] = 0;
+  }
+
+
+  total_entries = timer_table->full ? MAX_TIMER_ENTRIES : timer_table->current_entry;
+  for(entry = 0; entry < total_entries; entry++){
+  	accumulated_cycles = timer_table->interval_end[entry] - timer_table->interval_start[entry];
+  	if (accumulated_cycles > 0ULL) {
+	    BOM = binary_order_of_magnitude(accumulated_cycles*TIMER_SCALE_FACTOR/timer_table->interval_elems[entry]);
+	    BOM_count[BOM]++;
+	    BOM_elems[BOM] += timer_table->interval_elems[entry];
+	    BOM_total_time[BOM] += accumulated_cycles;
+	}
+  }
+  
+  printf("Binary Order of Magnitude Profile\n");
+  for (b = 0; b < BIT_COUNT; b++) {
+    this_count = BOM_count[b];
+    cum_count += this_count;
+    this_time = BOM_total_time[b];
+    cum_time += this_time;
+    this_elems = BOM_elems[b];
+    cum_elems += this_elems;
+    if (this_count == 0) this_avg = 0ULL;
+    else this_avg = (TIMER_SCALE_FACTOR*this_time)/(this_elems);
+    if (cum_count == 0) cum_avg = 0ULL;
+    else cum_avg = (TIMER_SCALE_FACTOR*cum_time)/(cum_elems);
+    if (this_count > 0) {  // Only report intervals with nonzero counts.
+      printf("BOM %i: %i ", b, this_count);
+      printf("(avg time: %i %s/kElem) ", (int) this_avg, cycle_counter_units);
+      printf("Cumulative: %i ", cum_count);
+      printf("(avg: %i %s/kElem)\n", (int) cum_avg, cycle_counter_units);
+    }
+  }           
+}
+#endif