Eu pude entender essa preocupação fortemente em áreas em que você está cobrindo cada centímetro do hardware, como um mecanismo de jogo AAA de última geração multithread que usa todos os núcleos de CPU, intrínsecas SIMD, GPU, GPGPU etc., oferecendo uma plataforma cruzada produtos.
Nesses casos, seu pior pesadelo costuma ser aqueles em que seus testes (unidade e integração) serão aprovados nas primeiras 5.000 máquinas / plataformas diferentes testadas, mas falham na 5.001 devido a um bug no driver de um modelo obscuro de GPU. sobre isso me dá arrepios - você não pode testar ou prever com antecedência.
Especialmente se você escrever shaders de GPU, poderá terminar jogando na loteria reversa, onde metade do código que escrever invocará um comportamento indefinido, pois existem poucas garantias padrão portáteis aplicadas por todos os modelos / drivers de GPU envolvidos. Embora hoje em dia esteja cada vez menos parecido com jogar caça-minas, isso deve dar às pessoas uma idéia: http://theorangeduck.com/page/writing-portable-opengl . Tentar isso no final dos anos 90 e no início dos anos 2000 foi realmente horrível, e foi todo o caminho.
Para esses tipos de casos, muitas vezes você precisa de equipes de mais de 10.000 testadores com uma ampla gama de hardware e sistemas operacionais para solidificar o produto e se sentir confiante em relação a ele antes de uma versão estável. Nem todas as empresas podem se dar ao luxo de ter uma base de testes tão ampla e nem todas têm a disciplina necessária para fazer isso corretamente (todos os problemas amplamente visíveis devem ser corrigidos antes de haver tantos testadores em algum estágio pré-alfa / alfa interno, ou então o uma inundação de relatórios redundantes pode levar os desenvolvedores a entrar em pânico.
O que eu recomendo neste caso é o que os outros sugeriram, focar em um conjunto distribuído de testes de integração. Você pode agrupá-lo com o instalador, exigindo que os usuários passem por uma verificação de diagnóstico básica com muita atenção para fornecer detalhes de por que a instalação falhou e que eles podem passar para você, os desenvolvedores.
Outra coisa (se você pode convencer o chefe) é ter uma ampla gama de hardware disponível para fazer a integração contígua. Quanto maior a variedade de combinações de hardware / sistema operacional, melhor. Você deseja até uma variedade de hardware de baixa qualidade que modela os requisitos mínimos de hardware para seus servidores de CI: você nunca sabe.
Mas há mais uma coisa que eu sugiro:
Exploração madeireira
Se você estiver lidando com algo parecido com o cenário descrito acima, geralmente não poderá testar essas coisas que tendem a ser as mais problemáticas (aquelas piores dicas possíveis que aparecem no pior momento possível e não podem aparecer nem no suíte de testes mais exaustiva, pois é um problema restrito a um conjunto muito específico de hardware / sistema operacional).
No entanto, a maioria desses tipos de problemas, como incompatibilidades obscuras de hardware, falhas diretas de driver ou vinculação ao dylib errado (eu nunca realmente enfrentei essa preocupação), não vai demorar muito para iniciar o software. Normalmente vai falhar e queimar muito em breve, falando mal.
Eu recomendo, por uma questão de sanidade, abraçar o inevitável. Você não pode fazer nada sobre essas coisas que você não pode testar de forma abrangente. Não tente impedir o furacão (impossível), mas feche essas janelas.
Normalmente, aqui, a melhor coisa que podemos fazer é descobrir o problema o mais rápido possível, onde ocorre o mais detalhado possível (para restringir nossa lista de suspeitos) e corrigir o problema o mais rápido possível após a denúncia.
Nesse caso, o log pode ser um salva-vidas. Para esses tipos de campos, você pode criar esses logs técnicos com spam, que ninguém jamais leria. Frequentemente relevante é apenas a última linha registrada no log antes do usuário enfrentar uma falha devido a uma falha no driver, por exemplo, você pode gravar um processo externo ou um gancho que monitora falhas e mostra a última linha do log que os usuários podem copiar e cole para você, por exemplo, além de um despejo de memória.
Como isso geralmente requer informações granulares e muitas das áreas mais suscetíveis de código a esses problemas de hardware / plataforma / driver são críticas para o desempenho, existe um problema estranho em que o log pode estar acontecendo a uma taxa tão frequente que, na verdade, diminui abaixo do software.
Um truque útil nesse caso é confiar na suposição de que algo executado uma vez será executado com sucesso na segunda vez, terceira vez etc. Essa não é a suposição mais sólida, mas geralmente é "suficientemente boa" (e infinitamente melhor que nada) . Com isso, você pode usar um pouco de estado externo para acompanhar quando algo já foi registrado e pular tentativas subseqüentes de registrar casos realmente granulares nos quais o código será invocado repetidamente em um loop.
Enfim, espero que isso ajude. Eu já enfrentei esse tipo de tentação no passado e tenho um pouco de paranóia em torno da codificação da GPU (GPGPU e shaders) como resultado de algumas experiências passadas entre mim e minha equipe (às vezes, apenas vendo outros membros da equipe lidando com isso realmente tarde e pós-lançamento me deram arrepios, como algumas falhas da ATI em um modelo específico da Radeon que trava ao renderizar linhas antialias, mais tarde relatadas e marcadas como um problema conhecido, com apenas uma solução alternativa disponível).
O registro foi o que salvou nossos objetivos, permitindo que vejamos com freqüência o problema na 10.001ª máquina de protótipo obscura com uma GPU integrada que nunca ouvimos falar, com a última linha de código nos permitindo identificar exatamente onde a falha foi reduzida a 2 ou 3 linhas de código como suspeito, por exemplo, se estiver dentro de um shader elaborado, somos um tipo de SOL, já que não podemos fazer logon dentro de um shader de GPU, mas podemos pelo menos usar o log para ver qual shader teve o problema imediatamente para iniciar a investigação.