Inicio>Relacionado con la programación>C/C++
Descargar

Fast_io

Fast_io es una biblioteca de entrada/salida C ++ 20 que proporciona una velocidad excepcional y está diseñada para reemplazar las bibliotecas <iostream> y <cstdio> comúnmente utilizadas. Es una biblioteca solo de encabezado y tiene licencia bajo la licencia MIT, lo que facilita incluir en cualquier proyecto. Sin embargo, requiere un compilador C ++ 20 que admite conceptos.

El repositorio original de FAST_IO se ha archivado debido a la hinchazón de GIT con el tiempo, pero todavía se pueden encontrar compromisos más antiguos allí. Los viejos compromisos estaban aquí.

Ejemplos

Imprimir a stdout 

# include < fast_io.h >

int main () {
	print ( " Hello, fast_io world! n " );
}

Archivo de mapa de memoria 

# include < fast_io.h >

int main () {
	fast_io::native_file_loader file_data ( " text.txt " );
	// file_data satisfies std::ranges::contiguous_range
}

Otros ejemplos

Para otros ejemplos actualizados, busque los examples/ carpeta.

Los ejemplos desapercibidos están aquí, pero es posible que ya no funcionen.

Este repositorio i18n almacena los archivos de origen I18N.

https://bitbucket.org/ejsvifq_mabmip/fast_io_i18n

Preguntas frecuentes

¿Qué significa "rápido" en Fast_io?

El término fast en fast_io no implica necesariamente que sea la biblioteca de entrada/salida más rápida disponible (ya que habría sido nombrada como fastest_io ). En cambio, el término se refiere al hecho de que fast_io es notablemente más rápido que <iostream> y <cstdio> bibliotecas en todos los casos.

¿Cuáles son las plataformas compatibles, compiladores ...?

Consulte Support.MD para obtener una lista de cosas compatibles y notas de uso específicas de la plataforma.

Otras preguntas?

Puede hacer preguntas en el servidor Fast_io Discord o el grupo QQ: 801441303 .

Documentación

Vea https://ewindy.gitee.io/fast_io_rst/index.html o https://giteee.com/qabeowjbtkwb/fast_io/wikis.

Características

  • Lo más cerca posible de la llamada del sistema.

  • Unicode Support (UTF-8, UTF-16, UTF-32) + CodeCVT para GB18030 y UTF-EBCDIC (ningún LibC trata correctamente con él)

  • RAII para FILE* , POSIX fd y WIN32/NT HANDLE

  • INATOP CON <cstdio> y <iostream>

  • No hay cosas fácilmente mal utilizadas como std::endl

  • Manipuladores de E/S estáticos en lugar de cadenas de formato.

  • Localidad opcional.

  • Manipulación de E/S apátrate.

  • Manejo constante de errores; Cuando esté disponible, excepciones como el único mecanismo de informes de errores (sin std::error_code , std::system_error o Comprobación de límites inútiles)

  • Modo independiente.

  • Dirección de código especial desinfectante para proteger los problemas de seguridad de la memoria.

  • Soporte de instrumentación dinámica

  • Admite Posix Iconv. Puede usar Fast_io para su conversión de codificación.

  • Serialización binaria para tipos y contenedores estándar trivialmente copiables

  • Se reproduce bien con los contenedores C ++ (por ejemplo std::vector<fast_io::obuf_file> es válido)

  • Formato básico/lua/python/etc (impresión, escaneo). No hay soporte para C y C ++, ya que son riesgos de seguridad.

  • Proporcione API para exponer la implementación interna de las transmisiones FILE* y C ++.

  • Interfaz de mango nativo

  • Dispositivos personalizados extremadamente fáciles de admitir

  • El tiempo de compilación de estilo C y C ++ de tiempo de compilación de modo abierto.

  • Sin traits_type y EOF

  • Soporte de tipo dinámico

  • Proceso múltiple

  • Mapeo de memoria

  • Depuración IO (opcionalmente con GUI)

  • Algoritmo de punto flotante de ida y vuelta

  • Soporte de algoritmos hash: SHA-1 intrínseco, HMAC-SHA1 intrínseco, SHA-256 intrínseco, HMAC-SHA256 intrínseco, SHA-512, HMAC-SHA512, así como algoritmos de hash no criptográficos, como Jenkins Cascos.

  • compresión de zlib/descompresión

  • Sistema de archivos

  • Openssl Bio, Qt Qfile, MFC CFile Support

Publicar C ++ 20

  1. Soporte del módulo
  2. Soporte de Coroutine para Async IO
  3. Mejorar y refactorizar el código una vez que se agregan excepciones deterministas de sobrecarga cero al estándar

Puntos de referencia

  1. I/O 10m enteros

Objetivo: imprima diez millones de enteros de 0 a 10m a archivo. Luego vuelva a abrir ese archivo para escanear.

Todos los puntos de referencia están en puntos de referencia/0000.10m_size_t/unidad.

Aviso: Modifiqué el Bufsiz 1048576 de Libstdc ++ debido a Bufsiz es demasiado pequeño (512 bytes) para MingW-W64, o funciona horriblemente.

Plataforma Windows MINGW-W64 GCC 11.0.0 Msvcrt+ libstdc ++
Método Tiempo de salida Tiempo de entrada Comentario
stdio.h (fprintf/fscanf) 2.412987S 5.607791s
fstream 0.462012S 1.192s
fstream con rdbuf.sputc truco 0.33895s 1.170173S
Fast_io :: i/obuf_file 0.04903S 0.080996s
Fast_io :: i/obuf_file_mutex 0.146064S 0.113155s hilo seguro
c_locale_i/obuf_file ("c") 0.065988s 0.086012S Imbuido de localidad, localidad "C"
c_locale_i/obuf_file local 0.153995s imbuido de localidad, lugar ""
fmt :: format_int+obuf_file 0.122999s
fmt :: format_int+ofstream 0.209055S
FMT :: Formato+OfStream 0.548s FMT hace las cosas más lentas
fmt :: imprimir 0.663996s FMT hace las cosas más lentas
std :: to_chars+obuf_file 0.12s
std :: to_chars+ofstream 0.192s
Fast_io :: c_file_unlocked 0.098999s 0.126003S Hacké el archivo de MSVCRT* Implementación
Fast_io :: C_File 0.298988s 0.318001S Hilo seguro. Hacké el archivo de MSVCRT* Implementación
Fast_io :: fileBuf_File 0.048999s 0.081s Hacké la implementación de StreamBuf/FileBuf de Libstdc ++
Fast_io :: IOBUF_UTF8_FILE_CHAR16 0.124s 0.112001s UTF-16 => UTF-8 con SSE
Fast_io :: IOBUF_UTF8_FILE_CHAR32 0.110999s 0.111011s UTF-32 => UTF-8 con SSE
std :: wofstream 2.64s 3.843735S wofstream con std :: loce codeCvt. TBH extremadamente lento.
Fast_io :: wfileBuf_io_observer 2.415692s 2.497704S wofstream con std :: loce codeCvt. Esto demuestra que Fstream nunca puede solucionarse.
Lenguaje de óxido 0.483S El óxido es lento. Además, Rust no trata con el lugar. Piensa en lo malo que es.
Biblioteca de óxido itoa 0.4.6 > 0.165s Ignoré la parte n para asegurar que no hay sesgo.

El lenguaje de óxido es 10 veces más lento que Fast_io. + La hinchazón binaria y la biblioteca ITOA siguen siendo extremadamente lenta y utilizable para mí. Es al menos 3 veces más lento que Fast_io.

Ejecute la misma prueba en MSVC 19.26.28805.

Plataforma Windows MSVC 19.26.28805 Instalar fmtlib desata la hora de mi vida
Método Tiempo de salida Tiempo de entrada Comentario
stdio.h (fprintf/fscanf) 1.5353597s 1.4157233S
fstream 3.6350262s 3.84203339S
fstream con rdbuf.sputc truco 3.3735902S 3.8145566S
Fast_io :: i/obuf_file 0.0631433S 0.1030554S
Fast_io :: i/obuf_file_mutex 0.2190659S 0.2485886s hilo seguro
std :: to_chars+obuf_file 0.1641641s
std :: to_chars+ofstream 0.5461922s
Fast_io :: c_file_unlocked 0.1102575S 0.2399757s Hacké el archivo de Universal CRT* Implementación
Fast_io :: C_File 0.2034755S 0.2621148s Hilo seguro. Hacké el archivo de UCRT* Implementación
Fast_io :: fileBuf_File 0.126661s 0.2378803S Hacké la implementación StreamBuf/FileBuf de MSVC STL

Ejecute la misma prueba en GCC 11. GLIBC+ LIBSTDC ++

Plataforma Linux GCC 11.0.0 GLIBC+ LIBSTDC ++
Método Tiempo de salida Tiempo de entrada Comentario
stdio.h (fprintf/fscanf) 0.532792935S 0.591907111s
fstream con rdbuf.sputc truco 0.318896068S 0.429406415S
Fast_io :: i/obuf_file 0.050300857s 0.065372395S
Fast_io :: i/obuf_file_mutex 0.05290654s 0.083040518S hilo seguro
c_locale_i/obuf_file ("c") 0.051939052s 0.065820056S Imbuido de localidad, localidad "C"
c_locale_i/obuf_file local 0.162406082s imbuido de localidad, lugar ""
std :: to_chars+obuf_file 0.115453587s
fmt :: format_int+obuf_file 0.1183587s
fmt :: format_int+ofstream 0.195914384S
FMT :: Formato+OfStream 0.633590975S FMT hace las cosas más lentas
fmt :: imprimir 0.495270371s FMT hace las cosas más lentas
Boost :: iOStreams 0.400906063S 0.444717051s Usar Boost IOSTreams no hace que su código sea más rápido
Fast_io :: c_file_unlocked 0.060076723S 0.073299716s Hacké el archivo de GLIBC* Implementación
Fast_io :: C_File 0.092490191s 0.104545535s Hilo seguro. Hacké el archivo de GLIBC* Implementación
Fast_io :: fileBuf_File 0.052251608S 0.06655806s Hacké la implementación de StreamBuf/FileBuf de Libstdc ++

¡Puede ver que Fast_io también puede aumentar el rendimiento de las instalaciones existentes para 10x! Sí, incluso puede mejorar el rendimiento de Archivo* y FSTream para 10x dependiendo de las plataformas, ya que uso conceptos para abstraerlos a todos. fmtlib en realidad ralentiza el rendimiento de E/S.

  1. Salida 10m Doble en modo de ida y vuelta con algoritmo RYU

Solo realizamos esta prueba para MSVC ya que solo la CharConv de MSVC lo implementa. Sí. Fast_io derrota el CharConv de MSVC por más del 20% por ejecutar el mismo algoritmo.

Todos los puntos de referencia están en puntos de referencia/0001.10m_double/charconv.

Ejecute la misma prueba en MSVC 19.26.28805.

Plataforma Windows MSVC 19.26.28805
Método Tiempo de salida Comentario
i/obuf_file 0.4653818s
charconv + obuf_file 0.6011s
  1. Rendimiento de E/S en bruto

Todos los puntos de referencia están en puntos de referencia/0014.file_io/file_io.

Salida 10000000000X "Hola Mundo n"

AVISO: Modifiqué el bufsiz de FileBuF+'s STD :: FileBuf a 1048576 debido a que Bufsiz es demasiado pequeño (512 bytes) para MingW-W64 o funciona horriblemente.

Plataforma Windows MINGW-W64 GCC 11.0.0 Msvcrt+ libstdc ++
Método Tiempo de salida Comentario
fritizar 2.524001S
fstream 1.013001S
Fast_io :: obuf_file 0.437998S
Fast_io :: obuf_file_mutex 1.371s Hilo seguro
Fast_io :: c_file_unlocked 1.164997s Hacké el archivo de MSVCRT* Implementación
Fast_io :: C_File 3.337945S Hilo seguro. Hacké la implementación del archivo* de MSVCRT*. Necesita más optimización
Fast_io :: fileBuf_File 0.467001S Hacké la implementación STD :: FileBuf de Libstdc ++
Plataforma Linux GCC 11.0.0 GLIBC+ LIBSTDC ++
Método Tiempo de salida Comentario
fritizar 1.457288317s
fstream 1.249783346s
Fast_io :: obuf_file 0.494827134S
Fast_io :: obuf_file_mutex 0.497138826s Hilo seguro
Fast_io :: c_file_unlocked 0.687976666S Hacké el archivo de GLIBC* Implementación
Fast_io :: C_File 0.910792697s Hilo seguro. Hacké el archivo de GLIBC* Implementación
Fast_io :: fileBuf_File 0.526955039S Hacké la implementación STD :: FileBuf de Libstdc ++
Plataforma Windows MSVC 19.26.28805 UCRT + MSVC STL
Método Tiempo de salida Comentario
fritizar 3.3139122s
fstream 1.7184119s
Fast_io :: obuf_file 0.7996034S
Fast_io :: obuf_file_mutex 2.2949221s Hilo seguro. Parece que std :: mutex es horriblemente lento para MSVC STL.
Fast_io :: c_file_unlocked 1.2103924s Hacké el archivo de UCRT* Implementación
Fast_io :: C_File 2.3604295S Hilo seguro. Hacké el archivo de UCRT* Implementación
Fast_io :: fileBuf_File 1.2805368S Hacké la implementación STD :: FileBuf de MSVC STL
  1. Tamaño binario solo use el punto de referencia en puntos de referencia/0014.file_io/file_io. Amigo, debes evitar la corriente como peste tbh. No es saludable.
Plataforma Windows MINGW-W64 GCC 11.0.0 Msvcrt + libstdc ++ + compilación estática
Método Tamaño binario Comentario
fstream 925kb Usar fstream no es bueno para su salud ya que std :: loce se inclina su binario.
Fast_io :: obuf_file 155kb
Fast_io :: c_file_unlocked 157kb Hacké el archivo de MSVCRT* Implementación
Fast_io :: C_File 157kb Hilo seguro. Hacké el archivo de MSVCRT* Implementación
Fast_io :: fileBuf_File 933kb Hacké en la implementación STD :: FileBuf de Libstdc ++. La transmisión C ++ apesta
  1. Código Convertir

Generar 100000000? emojis utilizando el programa en puntos de referencia/0020.utf/fill_nc.cc

Los puntos de referencia están en ejemplos/0043.iconv Universal Iconv. (UTF-8 a GB18030 como ejemplo) Prueba de iconv:

Plataforma Windows MINGW-W64 GCC 11.0.0 Msvcrt+ libstdc ++
Método Tiempo transcurrido Comentario
comando iconv 1.529s
universal.cc 1.293S Use Posix Libiconv

UTF8-> UTF16LE

Los puntos de referencia están en ejemplos/0022.Utf

Prueba de iconv:

Plataforma Windows MINGW-W64 GCC 11.0.0 Msvcrt+ libstdc ++
Método Tiempo transcurrido Comentario
comando iconv 0.967s GNU iconv. No habita que apesta
utf8_file_to_utf16_file.cc 0.498s Utilizo los algoritmos SSE proporcionados por el proyecto UTF-Utils.

UTF8-> UTF32LE

Los puntos de referencia están en ejemplos/0022.Utf

Prueba de iconv:

Plataforma Windows MINGW-W64 GCC 11.0.0 Msvcrt+ libstdc ++
Método Tiempo transcurrido Comentario
comando iconv 0.844s GNU iconv. No habita que apesta
utf8_file_to_utf32_file.cc 0.442s Utilizo los algoritmos SSE proporcionados por el proyecto UTF-Utils.

Créditos

La creación y el desarrollo de este proyecto fueron posibles gracias a las valiosas contribuciones de varios proyectos de código abierto. Si bien el código no se copió directamente de estos proyectos, los utilicé como referencias y los volví a implementar para adaptarse a los propósitos específicos de esta biblioteca. En algunos casos, surgieron problemas de integración que requerían modificaciones al código original. Estoy agradecido con estos proyectos y sus desarrolladores por su compromiso de hacer que su código sea abierto y accesible para la comunidad en general.

Proyecto Url
Grisu-exacto https://github.com/jk-jeon/grisu-exact
Ryu https://github.com/ulfjack/ryu
SHA-Intrinsics https://github.com/noloader/sha-intrinsics
SHA1 https://github.com/vog/sha1
UTF-UTILS https://github.com/bobsteagall/utf_utils
Jenkins-Hash-Java https://github.com/vkandy/jenkins-hash-java
MD5 https://github.com/jieweiwei/md5
Reactos https://github.com/reactos/reactos
dirent_h https://github.com/win32ports/dirent_h
Biblioteca GNU C https://www.gnu.org/software/libc/
GNU Newlib https://sourceware.org/newlib/
Dragón https://github.com/jk-jeon/dragonbox
Jeaiii https://github.com/jeaiii/itoa
Cripto ++ https://github.com/weidai11/cryptopp
Myitoa https://gitee.com/xjkp2283572185/mystd
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo