Em uma palavra simples: Não.
O que desperdiça muito esforço é alternar entre o espaço do kernel e o espaço do usuário, essa comutação é onde o maior desperdício é produzido. Há (muito) trabalho apenas para chegar onde a operação real precisa ser executada. Quanto menos switches precisassem da operação mais eficiente deveria ser.
Existem operações que são feitas completamente no espaço do kernel (e não há maneira (segura) de contornar isso). Nesses casos, a maior parte do tempo é gasto no espaço do kernel, e essa é a maneira mais eficiente de executá-los.
Existem outras operações que devem ser executadas no espaço do usuário, pois o kernel não possui serviço / função que o implemente. Em tais operações, quanto mais tempo for usado no espaço do usuário, mais eficiente será a operação.
Mas alguém pode ter implementado um serviço de kernel eficiente no espaço do usuário com algum algoritmo não tão eficiente. Isso aumentará o tempo do usuário, mas o resultado seria menos eficiente. Comparado com o mesmo serviço no espaço do kernel.
E algum outro desenvolvedor pode estar chamando o kernel para ler um byte de cada vez (e ter que alternar para cada byte) em vez da chamada equivalente para ler um meg de cada vez (se houver uma função equivalente para um bloco em vez de um byte).
E, no final, deve ser que alguma mistura de operações do kernel e do usuário seja executada. Para ler um bloco de disco, por exemplo, o kernel deve fornecer a função e deve ser um "disparar e esquecer" até que o bloco de memória (buffer) seja preenchido com o resultado da leitura do bloco de disco. Para acessar a memória do processo (como uma matriz de programa), nenhuma chamada de kernel deve ser necessária.
Não há uma maneira simples de medir a eficiência do tempo.