lzop2_multi.c

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
                      #2023 X March 21 19:50 PM Brasília Time
 
*                                                                             *
*                   Licensa de Copia (C) <2023>  <Aurora Boreal>              *
*                                                                             *
*     Este  programa  e software livre: voce pode redistribuir isto e/ou      *
*     modificar  isto sobre os termos do  GNU Licensa Geral Pública como     25
*     publicado  pela Fundacao  de Software  Livre, tanto a versão 3  da      *
*     Licensa, ou (dependendo da sua opcao) qualquer versao posterior.        *
*                                                                             *
*     Este  programa e distribuido na  esperanca que isto vai  ser util,      *
*     mas SEM  QUALQUER GARANTIA; sem  ate mesmo a implicada garantia de      *
*     COMERCIALIZAcaO ou CABIMENTO PARA UM FIM PARTICULAR.  Veja a            *
*     Licensa Geral Publica para mais detalhes.                               *
*                                                                             *
*     Você deve ter recebido uma  cópia da LICENSA GERAL PUBLICA e a GNU      *
*     Licensa Publica Menor junto com este programa                           *
*     Se não, veja <http://www.gnu.org/licenses/>.                            *
*                                                                             *
*     Suporte: sourceforge.net github.com                                   *
*                                                                             *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
*       Pereira: arsoftware25@gmail.com ricardo@arsoftware.net.br             *
*           xcx: arsoftware10@gmail.com   charli@arsoftware.net.br            *
         Yasmin:                          yasmin@arsoftware.net.br            *
                                              pereira1001@users.sourceforge.net
                                                                             */
 
 
                                                                            
double
inittimer2_8(int value)
{
 
     static double freq = 0;
     static LARGE_INTEGER first;
     static LARGE_INTEGER second;
 
     if (0 == value)
     {
 
          if (freq == 0)
          {
 
               QueryPerformanceFrequency(&first);
               freq = (double)first.QuadPart;
          }
 
          QueryPerformanceCounter(&first);
 
          return 0;
     }
 
     if (1 == value)
     {
 
          QueryPerformanceCounter(&second);
 
          second.QuadPart = second.QuadPart - first.QuadPart;
 
          return (double)second.QuadPart / freq;
     }
 
     return 0;
}
 
static uint64_t bytes_in_each_slice_z[129];
static uint64_t offset_of_each_slice_z[129];
 
extern int *cores_used_z_8;
 
#include "lzop2_thread.c"
 
int __valquiriacall compress2_uncompress_k_real_mt_z_8(char *input_z, char *output_z)
{
     my_thread_struct_z *ptr_my_struct_z;
     FILE *dest_z = NULL;
     FILE *input_file;
     FILE *temp_z = NULL;
     int ret_z;
     bool adjust_z = true;
     int ret2_z;
     int retvalue_z = 0;
     int n_threads_copy;
     int n_thread_counter;
     int ret_arp;
     int thread_counter = 0;
     int i_z;
     int64_t remaining_z;
     char signature_z[5] = "AR__";
     static char buffer[CHUNK];
     ar_data ar = {0};
 
     pedro_dprintf(-1, "dentro threads %d\n", n_threads_z_8);
 
     thread_return_value_z_8 = 0; //initial thread error value
 
     //n_threads_copy = n_threads_z_8;
 
     n_thread_counter = 0;
 
     //primeiro precisa detectar quantos threads foram usados no arquivo compactado
 
     {
    
          input_file = _wfopen(utf8_2_wide_dl(input_z), L"rb");
 
     }
     /* removing weird code... ;-)
     else
          input_file = fopen(input_z, "rb"); //never will be called, don´t be afraid
     */
     if (NULL == input_file)
     {
          return 1; //Cannot open input file
     }
 
     signature_z[3] = 0x53; // new lzop2 multi-thread and single-thread signature
 
     while (1)
     {
 
          memset(&ar, 0, sizeof(ar));
          ret_arp = fread(&ar, 1, sizeof(ar), input_file);
 
          if (0 == ret_arp)
          {
               goto saida_z;
          }
 
          if (ret_arp != sizeof(ar))
          {
               retvalue_z = 5;
               goto saida_z;
          }
 
          if (0 != memcmp(ar.string, signature_z, 4))
          {
               pedro_dprintf(-1, "erro 7\n");
               retvalue_z = 7;
               goto saida_z;
          }
 
          ret_arp = fread(&remaining_z, 1, sizeof(remaining_z), input_file);
 
          if (sizeof(remaining_z) != ret_arp)
          {
               retvalue_z = 5;
               goto saida_z;
          }
          bytes_in_each_slice_z[thread_counter] = remaining_z;
          offset_of_each_slice_z[thread_counter] = _ftelli64(input_file);
 
          pedro_dprintf(-1, "itens %lld %lld\n",
                        bytes_in_each_slice_z[thread_counter],
                        offset_of_each_slice_z[thread_counter]);
 
          _fseeki64(input_file, remaining_z, SEEK_CUR);
 
          thread_counter++;
     }
 
saida_z:;
 
     fclose(input_file);
 
     pedro_dprintf(0, "8count of threads %d\n", thread_counter);
 
     if (retvalue_z)
     {
          return 7;
     }
 
     //exit(27);
 
     n_threads_z_8 = thread_counter;
 
     assert(cores_used_z_8);
 
     *cores_used_z_8 = n_threads_z_8;
 
     n_threads_copy = thread_counter;
     pedro_dprintf(-1, "veja 1\n");
 
     inittimer2_8(0);
 
     while (n_threads_copy--)
     {
          pedro_dprintf(-1, "running thread %d\n", n_thread_counter);
 
          ptr_my_struct_z = calloc(1, sizeof(my_thread_struct_z));
          assert(ptr_my_struct_z);
 
          ptr_my_struct_z->thread_id_z = n_thread_counter;
 
          {
               
               ptr_my_struct_z->input_file = _wfopen(utf8_2_wide_dl(input_z), L"rb");
 
          }
 
          intpause_8 = 0;
          intcancel_8 = 0;
 
          ptr_my_struct_z->intpause_8 = &intpause_8;
          ptr_my_struct_z->intcancel_8 = &intcancel_8;
 
          bytes__read_thread_z_8[n_thread_counter] = 0;
 
          ptr_my_struct_z->bytes_read_z =
              &bytes__read_thread_z_8[n_thread_counter];
 
          ptr_my_struct_z->size_of_input_file_z = ptr_my_struct_z->size_of_input_file_copy_z = bytes_in_each_slice_z[n_thread_counter];
 
          ptr_my_struct_z->offset_z =
              offset_of_each_slice_z[n_thread_counter];
 
          if (!createtempfilename_and_keep_z_8(temp_path_z_8, temp_files_z_8[n_thread_counter], "LZ2"))
          {
               if (0 == thread_return_value_z_8)
               {
                    thread_return_value_z_8 = 407; //Cannot create temp file
               }
          }
          else
          {
               if (true)
               {
#ifdef ARP_USE_ENHANCED_STDIO
                  
                    ptr_my_struct_z->dest = fopen(temp_files_z_8[n_thread_counter], "wb");
                    
#else
#error stdio
                    ptr_my_struct_z->dest = _wfopen(wpmode, L"wb");
#endif
               }
 
               if (NULL == ptr_my_struct_z->dest)
               {
                    if (0 == thread_return_value_z_8)
                    {
                         thread_return_value_z_8 = 405; //Cannot open output tempfile
                    }
               }
          }
 
          my_thread_handle_8[n_thread_counter] = (__INT32_OR_INT64)_beginthreadex(NULL, 0, my_thread_function_v27_8, ptr_my_struct_z, 0, NULL);
 
          n_thread_counter++;
     }
 
     for (i_z = 0; i_z < n_threads_z_8; i_z++)
     {
          WaitForSingleObject((void *)my_thread_handle_8[i_z], INFINITE);
          CloseHandle((void *)my_thread_handle_8[i_z]);
          pedro_dprintf(-1, "Close next\n");
     }
 
     pedro_dprintf(-1, "comprimiu em %.3f\n", inittimer2_8(1));
 
     if (true)
     {
 
          SetFileAttributesW(utf8_2_wide_dl(output_z), FILE_ATTRIBUTE_ARCHIVE);
 
     }
 
     //abrir arquivo
 
     {
 
          dest_z = _wfopen(utf8_2_wide_dl(output_z), L"wb");
 
     }
 
     if (NULL == dest_z)
     {
          if (0 == thread_return_value_z_8)
          {
               thread_return_value_z_8 = 2; //Cannot open output file
          }
     }
 
     inittimer2_8(0);
     //depois de finalizar
     for (i_z = 0; i_z < n_threads_z_8; i_z++)
     {
          pedro_dprintf(-1, "arquivo temp a del %s\n", temp_files_z_8[i_z]);
          if (dest_z)
          {
 
               if (true)
               {
#ifdef ARP_USE_ENHANCED_STDIO
                   
                    temp_z = fopen(temp_files_z_8[i_z], "rb");
 
#else
                    temp_z = _wfopen(wpmode, L"rb");
#endif
               }
 
               if (temp_z)
               {
                    //Mr. Do
 
               volta_amanda:;
#ifdef ARP_USE_ENHANCED_STDIO
                    ret_z = fread(buffer, 1, CHUNK, temp_z);
#else
                    ret_z = fread(buffer, 1, CHUNK, temp_z);
#endif
                    if (0 > ret_z)
                    {
                         if (0 == thread_return_value_z_8)
                         {
                              thread_return_value_z_8 = 5; //Cannot read from input file
                         }
                    }
                    else if (0 == ret_z)
                    {
                         ; //just go by...
                    }
                    else
                    {
                         adjust_z = false; //debugging
                         if (adjust_z)
                         {
                              pedro_dprintf(-1, "vai ajustar %s\n", output_z);
                              adjust_z = false;
 
                              ret2_z = _chsize_s(_fileno(dest_z), 295226633);
                              pedro_dprintf(-1, "value must be 0\n", ret2_z);
                         }
                         ret2_z = fwrite(buffer, 1, ret_z, dest_z);
 
                         if (ret2_z != ret_z)
                         {
                              if (0 == thread_return_value_z_8)
                              {
                                   thread_return_value_z_8 = 6; //Cannot write to output file
                              }
                              goto exit_loop_z;
                         }
                         //to make the compiler happy...
 
                         ret2_z = 0;
                         ret2_z++;
 
                         if (-1 == ret2_z)
                         {
                              ret2_z = -2;
 
                              return ret2_z;
                         }
 
 
                         goto volta_amanda;
                    }
 
               exit_loop_z:;
 
                    fclose(temp_z);
 
               }
               else
               {
                    if (0 == thread_return_value_z_8)
                    {
                         thread_return_value_z_8 = 405; //Cannot open temp file
                    }
               }
          }
 
          unlink(temp_files_z_8[i_z]); // future fix here
 
     }
 
     pedro_dprintf(-1, "demorou 1 %.3f\n", inittimer2_8(1));
 
     inittimer2_8(0);
 
     //precisa setar isto antes de retornar
     
     pedro_dprintf(-1, "demorou 2 %.3f\n", inittimer2_8(1));
     pedro_dprintf(-1, "final finalmente\n");
 
     if (dest_z)
     {
          fclose(dest_z);
     }
 
     //exit(27);
     finished_8 = 1; //e depois return
     intstatus_8 = 0;
     return thread_return_value_z_8;
 
     pedro_dprintf(-1, "final ...%s %d\n", temp_path_z_8, (int)thread_return_value_z_8);
     exit(27);
     return 0;
}