eddelbuettel commented on issue #6435:
URL: https://github.com/apache/arrow/issues/6435#issuecomment-964781450


   So ... while turning `ccache` off worked on my Ubuntu machines, I just hit 
the proverbial wall on a Debian (headless) server used for bulk packages 
checks.   As before with `ccache` in `CC` etc, it dies. But turning it off 
leads to minutes of compilation (it an old machine...) only to later die on
   
   ```
   [...]
   g++  -std=gnu++11 -I"/usr/share/R/include" -DNDEBUG 
-I/tmp/RtmpX4TGco/R.INSTALL2c8b056f45c750/arrow/libarrow/arrow-6.0.0.2/include  
-DARROW_R_WITH_ARROW -DARROW_R_WITH_PARQUET -DARROW_R_WITH_DATASET -DARROW_R_WI
   TH_JSON -I../inst/include/     -fpic  -g -O2 -Wall -pipe  
-Wno-deprecated-declarations -Wno-parentheses -Wno-maybe-uninitialized 
-Wno-unused -Wno-sign-compare -Wno-ignored-attributes -c type_infer.cpp -o 
type_in
   fer.o                             
   g++ -std=gnu++11 -Wl,-S -shared -L/usr/lib/R/lib -Wl,-z,relro -o arrow.so 
RTasks.o altrep.o array.o array_to_vector.o arraydata.o arrowExports.o buffer.o 
chunkedarray.o compression.o compute-exec.o compute.o con
   fig.o csv.o dataset.o datatype.o expression.o feather.o field.o filesystem.o 
imports.o io.o json.o memorypool.o message.o parquet.o py-to-r.o r_to_arrow.o 
recordbatch.o recordbatchreader.o recordbatchwriter.o sc
   alar.o schema.o symbols.o table.o threadpool.o type_infer.o 
-L/tmp/RtmpX4TGco/R.INSTALL2c8b056f45c750/arrow/libarrow/arrow-6.0.0.2/lib 
-larrow_dataset -lparquet -larrow -larrow -larrow_bundled_dependencies -larr
   ow_dataset -lparquet -L/usr/lib/R/lib -lR                                    
                            
   installing to /home/dirk/tmp/lib/00LOCK-arrow/00new/arrow/libs
   ** R                                                                         
                            
   ** inst                                                                      
                            
   ** byte-compile and prepare package for lazy loading                         
                            
   ** help                                                                      
                                                                                
                                                      
   *** installing help indices                                                  
                            
   ** building package indices                                                  
                            
   ** installing vignettes                                                      
                                                                                
                                                      
   ** testing if installed package can be loaded from temporary location        
                                                                                
                                                      
                                                                                
                            
    *** caught illegal operation ***                                            
                            
   address 0x7ff09abf9e1e, cause 'illegal operand'                              
                            
                                                                                
                            
   Traceback:                                                                   
                            
    1: dyn.load(file, DLLpath = DLLpath, ...)                                   
                            
    2: library.dynam(lib, package, package.lib)                               
    3: loadNamespace(package, lib.loc)                                          
                                                                                
                                                      
    4: doTryCatch(return(expr), name, parentenv, handler)                       
                                                                                
                                                      
    5: tryCatchOne(expr, names, parentenv, handlers[[1L]])                      
                                                                                
                                                      
    6: tryCatchList(expr, classes, parentenv, handlers)                         
                                                                                
                                                      
    7: tryCatch({    attr(package, "LibPath") <- which.lib.loc    ns <- 
loadNamespace(package, lib.loc)    env <- attachNamespace(ns, pos = pos, deps, 
exclude, include.only)}, error = function(e) {    P <- if (!is.
   null(cc <- conditionCall(e)))         paste(" in", deparse(cc)[1L])    else 
""    msg <- gettextf("package or namespace load failed for %s%s:\n %s",        
 sQuote(package), P, conditionMessage(e))    if (logica
   l.return && !quietly)         message(paste("Error:", msg), domain = NA)    
else stop(msg, call. = FALSE, domain = NA)})                                    
                                                       
    8: library(pkg_name, lib.loc = lib, character.only = TRUE, logical.return = 
TRUE)                       
    9: withCallingHandlers(expr, packageStartupMessage = function(c) 
tryInvokeRestart("muffleMessage"))                                              
                                                                 
   10: suppressPackageStartupMessages(library(pkg_name, lib.loc = lib,     
character.only = TRUE, logical.return = TRUE))                                  
                                                           
   11: doTryCatch(return(expr), name, parentenv, handler)                       
                                                                                
                                                      
   12: tryCatchOne(expr, names, parentenv, handlers[[1L]])                      
                                                                                
                                                      
   13: tryCatchList(expr, classes, parentenv, handlers)                         
                                                                                
                                                      
   14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if 
(!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))         
    call <- sys.call(-4L)        dcall <- deparse(call)[
   1L]        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L       
 sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, 
type = "w") + nchar(sm[1L], type = "w")        if (is.
   na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],       
          type = "b")        if (w > LONG)             prefix <- paste0(prefix, 
"\n  ")    }    else prefix <- "Error : "    msg <- pa
   ste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L])) 
   if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, 
file = outFile)        .Internal(printDeferredWarnings()
   )    }    invisible(structure(msg, class = "try-error", condition = e))})    
                                                                                
                                                      
   15: try(suppressPackageStartupMessages(library(pkg_name, lib.loc = lib,     
character.only = TRUE, logical.return = TRUE)))                                 
                                                       
   16: tools:::.test_load_package("arrow", 
"/home/dirk/tmp/lib/00LOCK-arrow/00new")                                        
                                                                                
           
   An irrecoverable exception occurred. R is aborting now ...                   
                                                                                
                                                      
   Illegal instruction                                                          
                                                                                
                                                      
   ERROR: loading failed                                                        
                                                                                
                                                      
   * removing ‘/home/dirk/tmp/lib/arrow’                                        
                                                                                
                                                      
   * restoring previous ‘/home/dirk/tmp/lib/arrow’                              
                            
                                                                                
                                                                                
                                                      
   The downloaded source packages are in                                        
                                                                                
                                                      
           ‘/tmp/downloaded_packages’
   Warning message:                                                             
                                                                                
                                                      
   In install.packages(update[instlib == l, "Package"], l, contriburl = 
contriburl,  :                                                                  
                                                              
     installation of package ‘arrow’ had non-zero exit status                   
                                                                                
                                                      
   dirk@cloud-devel:~$ 
   ```
   
   System is as vanilla as they come and has thousand of CRAN packages install. 
 This is likely an issue with one of the imports out of sync.  Short of 
'rage-compiling' all of them, any suspicion which of
   
   >  assertthat, bit64 (≥ 0.9-7), methods, purrr, R6, rlang, stats, 
tidyselect, utils, vctrs
   
   may be most likely?
   
   
   
   
   
   
   assertthat, bit64 (≥ 0.9-7), methods, purrr, R6, rlang, stats, tidyselect, 
utils, vctrs
   --
   
   
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscr...@arrow.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


Reply via email to